Register the configuration publisher class and command.

@return void
334208
protected function registerAssetPublishCommand()
    {
        $this->app->bindShared('asset.publisher', function($app)
        {
            $publisher = new AssetPublisher($app['files'], $app['path.public']);

            //
            $path = $app['path.base'] .DS .'vendor';

            $publisher->setPackagePath($path);

            return $publisher;
        });

        $this->app->bindShared('command.asset.publish', function($app)
        {
            $assetPublisher  = $app['asset.publisher'];

            return new AssetPublishCommand($app['assets.dispatcher'], $assetPublisher);
        });
    }
474467
public function register() {
        //$this->registerPdfService();


        if ($this->app->runningInConsole()) {
            $this->registerResources();
        }

        $this->mergeConfigFrom(
            __DIR__ . '/../config/pdf.php', 'pdf'
        );

        $this->app->bind('pdf', function ($app) {
            return new PDF();
        });
    }
317922
public function register()
    {
        foreach ($this->commands as $binding => $command) {
            $bind    = $this->prefix . $binding;
            $command = '\\' . $this->namespace . '\\' . $command . $this->commandSuffix;
            unset($this->commands[ $binding ]);
            $this->commands[ $bind ] = $command;
            $this->app->singleton($bind, $command);
        }

        $this->commands(array_keys($this->commands));
    }
426976
protected function registerConfigPublisher()
    {
        $this->app->singleton('config.publisher', function ($app) {
            $path = $app->make('path.config');

            $publisher = new ConfigPublisher($app->make('files'), $path);

            $publisher->setPackagePath($app->make('path.base') . '/src');

            return $publisher;
        });
    }
984246
protected function registerPublisher(): void
    {
        $this->app->singleton('orchestra.publisher', function (Application $app) {
            $memory = $app->make('orchestra.platform.memory');

            return (new PublisherManager($app))->attach($memory);
        });
    }
781334
protected function registerConfigPublisher()
    {
        $this->app->singleton('config.publisher', function (Application $app) {
            $path = $app->configPath();

            // Once we have created the configuration publisher, we will set the default
            // package path on the object so that it knows where to find the packages
            // that are installed for the application and can move them to the app.
            $publisher = new ConfigPublisher($app->make('files'), $path);

            $publisher->setPackagePath($app->basePath().'/vendor');

            return $publisher;
        });
    }
160182
protected function registerConfigPublishCommand(): void
    {
        $this->app->singleton('command.config.publish', function (Application $app) {
            return new ConfigPublishCommand($app->make('config.publisher'));
        });
    }
220800
public function register()
    {

        // Package commands available for laravel or lumen higher than 5.1

        if(version_compare($this->app->version(), '5.1', ">=") or starts_with($this->app->version(), "Lumen")) {

            if ($this->app->runningInConsole()) {

                // Registering commands

                $this->commands([
                    ListIndicesCommand::class,
                    CreateIndexCommand::class,
                    UpdateIndexCommand::class,
                    DropIndexCommand::class,
                    ReindexCommand::class
                ]);

            }
        }

        $this->app->bind('es', function () {
            return new Connection();
        });
    }
1039252
protected function registerConfigBindings()
    {
        $loader = new FileLoader(new Filesystem(), $this->resourcePath('config'));

        $this->singleton('config', function () use ($loader) {
            return new Repository($loader, $this->environment());
        });
    }
1367933
public function register()
    {
        $this->app->bind(Proxy::class, function($app) {
            return new Proxy($app['config']->all());
        });

        $this->commands(
            Cmd\Backup::class
        );
    }
1324694
public function register()
    {
        // merge config
        $configPath = __DIR__ . '/config/config.php';
        $this->mergeConfigFrom($configPath, 'generators');

        // register all the artisan commands
        $this->registerCommand(PublishCommand::class, 'publish');

        $this->registerCommand(ModelCommand::class, 'model');
        $this->registerCommand(ViewCommand::class, 'view');
        $this->registerCommand(ControllerCommand::class, 'controller');

        $this->registerCommand(MigrationCommand::class, 'migration');
        $this->registerCommand(MigrationPivotCommand::class, 'migrate.pivot');
        $this->registerCommand(SeedCommand::class, 'seed');

        $this->registerCommand(NotificationCommand::class, 'notification');

        $this->registerCommand(EventCommand::class, 'event');
        $this->registerCommand(ListenerCommand::class, 'listener');
        $this->registerCommand(EventGenerateCommand::class, 'event.generate');

        $this->registerCommand(TraitCommand::class, 'trait');
        $this->registerCommand(RepositoryCommand::class, 'repository');
        $this->registerCommand(ContractCommand::class, 'contract');

        $this->registerCommand(JobCommand::class, 'job');
        $this->registerCommand(ConsoleCommand::class, 'console');

        $this->registerCommand(MiddlewareCommand::class, 'middleware');

        $this->registerCommand(ResourceCommand::class, 'resource');
        $this->registerCommand(FileCommand::class, 'file');
    }
1289357
public function register()
	{
		$this->app->bindShared('command.up', function($app)
		{
			return new UpCommand;
		});

		$this->app->bindShared('command.down', function($app)
		{
			return new DownCommand;
		});

		$this->commands('command.up', 'command.down');
	}
811628
public function register()
    {
        if (!defined('ADMINLTETEMPLATE_PATH')) {
            define('ADMINLTETEMPLATE_PATH', realpath(__DIR__.'/../../'));
        }

        if ($this->app->runningInConsole()) {
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\PublishAdminLTE::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\PublishAdminLTEAlt::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\PublishAdminLTESidebar::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\PublishAdminLTESidebarAlt::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\MakeAdminUserSeeder::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\AdminLTEAdmin::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\AdminLTEAdminAlt::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\MakeView::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\AdminLTEMenu::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\AdminLTEMenuAlt::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\MakeRoute::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\MakeMenu::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\MakeV::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\MakeVC::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\MakeMVC::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\Username::class]);
        }

        $this->app->bind('AdminLTE', function () {
            return new \Acacha\AdminLTETemplateLaravel\AdminLTE();
        });

        if (config('adminlte.gravatar', true)) {
            $this->registerGravatarServiceProvider();
        }

        if (config('adminlte.guestuser', true)) {
            $this->registerGuestUserProvider();
        }
        if (config('auth.providers.users.field', 'email') === 'username'  &&
            config('adminlte.add_nullable_username', true)) {
            $this->loadMigrationsFrom(ADMINLTETEMPLATE_PATH .'/database/migrations/username_login');
        }
    }
338201
public function register()
    {
        $this->registerBindings();

        $this->app['setting.settings'] = $this->app->share(function ($app) {
            return new Settings($app[SettingRepository::class]);
        });
        $this->app->booting(function () {
            $loader = AliasLoader::getInstance();
            $loader->alias('Settings', SettingsFacade::class);
        });

        $this->app['setting.themeOptions'] = $this->app->share(function ($app) {
            return new ThemeOptions($this->app['stylist']->current());
        });
    }
707683
private function registerPublishing()
    {
        if ($this->app->runningInConsole()) {
            $this->publishes([
                __DIR__.'/../public' => public_path('vendor/wink'),
            ], 'wink-assets');

            $this->publishes([
                __DIR__.'/../config/wink.php' => config_path('wink.php'),
            ], 'wink-config');
        }
    }
18617
public function register()
    {
        $this->app['themes'] = $this->app->share(function ($app) {
            return new Repository(
                new Finder(),
                $app['config'],
                $app['view'],
                $app['translator'],
                $app['cache.store']
            );
        });

        $this->registerCommands();
    }
824478
public function register()
    {
        $this->commands([
                ConsoleMakeCommand::class,
                ControllerMakeCommand::class,
                EnvironmentCommand::class,
                EventMakeCommand::class,
                JobMakeCommand::class,
                KeyGenerateCommand::class,
                ListenerMakeCommand::class,
                MailMakeCommand::class,
                MiddlewareMakeCommand::class,
                ModelMakeCommand::class,
                NotificationMakeCommand::class,
                ProviderMakeCommand::class,
                ResourceMakeCommand::class,
                TestMakeCommand::class,
            ]);
    }