Register the configuration publisher class and command.

@return void
165718
protected function registerConfigPublisher(): void
    {
        $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 Config($app->make('files'), $path);

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

            return $publisher;
        });
    }
499551
public function register()
    {
        $this->app->register(CmsServiceProvider::class);
        $this->app->register(CmsEventServiceProvider::class);
        $this->app->register(CmsRouteProvider::class);
        $this->app->register(CmsModuleProvider::class);

        $this->app->register(GrafiteBuilderProvider::class);
        $this->app->register(MinifyServiceProvider::class);
        $this->app->register(MarkdownServiceProvider::class);
        $this->app->register(ImageServiceProvider::class);

        $loader = AliasLoader::getInstance();

        $loader->alias('Minify', MinifyFacade::class);
        $loader->alias('Markdown', Markdown::class);
        $loader->alias('Image', Image::class);

        /*
        |--------------------------------------------------------------------------
        | Register the Commands
        |--------------------------------------------------------------------------
        */

        $this->commands([
            ThemeGenerate::class,
            ThemePublish::class,
            ThemeLink::class,
            ModulePublish::class,
            ModuleMake::class,
            ModuleComposer::class,
            ModuleCrud::class,
            Setup::class,
            Keys::class,
        ]);
    }
1367933
public function register()
    {
        $this->app->bind(Proxy::class, function($app) {
            return new Proxy($app['config']->all());
        });

        $this->commands(
            Cmd\Backup::class
        );
    }
1349910
public function boot()
    {
        // Register your migration's publisher
        $this->publishes([
            __DIR__.'/../database/migrations/' => base_path('database/migrations')
        ], 'migrations');
        
        // Publish your config
        $this->publishes([
            __DIR__.'/../config/config.php' => config_path($this->packageName.'.php'),
            __DIR__.'/../config/exampleClass.php' => app_path('Classes/Authorization/AuthorizationClass.php'),
        ], 'config');

        //
    }
1014880
public function register()
    {
        $this->mergeConfigFrom(__DIR__.'/../config/terminal.php', 'terminal');

        $this->app->singleton(Application::class, function ($app) {
            $config = $app['config']['terminal'];
            $artisan = new Application($app, $app['events'], $app->version());
            $artisan->resolveCommands($config['commands']);

            return $artisan;
        });

        $this->app->singleton(Kernel::class, function ($app) {
            $config = $app['config']['terminal'];

            return new Kernel($app[Application::class], array_merge($config, [
                'basePath' => $app->basePath(),
                'environment' => $app->environment(),
                'version' => $app->version(),
                'endpoint' => $app['url']->route(Arr::get($config, 'route.as').'endpoint'),
            ]));
        });
    }
967172
public function register()
    {
        $this->app->singleton('command.models.generate', function($app) {
            $db = $app['db.connection'];
            $driverClass = __NAMESPACE__.'\Drivers\\'.ucfirst($db->getDriverName()).'Driver';
            $driver = new $driverClass($db->getPdo());

            $builder = new Builder($app['config'], $driver);

            return new Console\GenerateCommand($builder);
        });

        $this->commands([
            'command.models.generate'
        ]);
    }
1086179
protected function registerMigrationService(): void
    {
        $config = $this->app['config'];
        $config->set('database.migrations', $config->get('database.migrations') ?: 'migrations');
        $this->app->register(\Illuminate\Database\MigrationServiceProvider::class);

        $this->app->alias(
            'migration.repository',
            \Illuminate\Database\Migrations\MigrationRepositoryInterface::class
        );

        $this->app->singleton(
            'migrator',
            function ($app) {
                $repository = $app['migration.repository'];

                return new Migrator($repository, $app['db'], $app['files']);
            }
        );

        $this->app->alias(
            'migrator',
            \Illuminate\Database\Migrations\Migrator::class
        );
    }
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();
        });
    }
1171195
public function register()
    {
        $this->registerManager();
        $this->app->singleton(
            'adminconfiguration', 
            \AvoRed\Framework\AdminConfiguration\Manager::class
        );
    }
408743
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/../config/pubsub.php', 'pubsub');

        $this->app->singleton('pubsub.factory', function ($app) {
            return new PubSubConnectionFactory($app);
        });

        $this->app->singleton('pubsub', function ($app) {
            return new PubSubManager($app, $app['pubsub.factory']);
        });

        $this->app->bind('pubsub.connection', PubSubAdapterInterface::class);

        $this->app->bind(PubSubAdapterInterface::class, function ($app) {
            $manager = $app['pubsub']; /* @var PubSubManager $manager */
            return $manager->connection();
        });

        $this->registerAdapterDependencies();

        $this->commands(SubscriberMakeCommand::class);
    }
949143
public function register()
    {
        // $this->configPath = config_path('laramin.php');
        $this->publishablePath = $this->getPublishablePath();
        $this->registerConsoleCommands();

        // $this->mergeConfigFrom($this->configPath, 'Laramin');
        $this->registerConfigs();
        $loader = AliasLoader::getInstance();
        $loader->alias('Laramin', LaraminFacade::class);

        $this->app->singleton('laramin', function ($app) {
            return new Laramin();
        });
        if ($this->app->runningInConsole()) {
            $this->registerPublishableResources();
        }
    }
243767
private function registerPackageConfig()
	{
		if (isLaravel5())
		{
	        $this->app->bindShared($this->packageName.'.config', function($app)
			{
				$configNameSpace = 'vendor.'.$this->packageVendor.'.'.$this->packageName.'.';
		        // Register the corresponding config for package
				return new $this->packageConfigClass($app['config'], $configNameSpace);
			});
			
		}

	}
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);
        });
    }
531783
public function register()
    {
        // Register the Artisan command binding
        $this->app->bind('stolz.assets.command.flush', function ($app) {
            return new FlushPipelineCommand();
        });
        // Merge user's configuration with the default package config file
        //$this->mergeConfigFrom(__DIR__ . '/config.php', 'assets');
        $config = $this->app['config']->get('assets.groups', []);
        // Register the library instances bindings ...
        // No groups defined. Assume the config is for the default group.
        if (! isset($config['default'])) {
            return $this->registerAssetsManagerInstance('default', $config);
        }
        // Multiple groups
        foreach ($config as $groupName => $groupConfig) {
            $this->registerAssetsManagerInstance($groupName, (array) $groupConfig);
        }
    }
1187926
public function register()
    {
        $this->app->singleton('asset', function ($app, $parameters = []) {
            if (count($parameters) < 2) {
                $parameters = array_merge($parameters, [null]);
            }
            list($dir, $path) = $parameters;

            return new Asset($dir, $path);
        });

        $this->app->bind('manifest', function ($app, $parameters = []) {
            if (count($parameters) < 2) {
                $parameters = array_merge($parameters, [null]);
            }
            list($dir, $path) = $parameters;

            return new Manifest($dir, $path);
        });

        // TODO: Allow to register or not Larasset commands in production env with a config option
        if ($this->app->environment() !== 'production' && $this->app['config']->get('app.debug')) {
            // For security reasons Larasset commands aren't available in production environment
            $this->registerCommands();
        }

        // TODO: Allow to publish default package.json in the config path of the package
    }
116737
public function register()
	{
        // Register the config publish path
        $configPath = __DIR__ . '/../config/translation-manager.php';
        $this->mergeConfigFrom($configPath, 'translation-manager');
        $this->publishes([$configPath => config_path('translation-manager.php')], 'config');

        $this->app->singleton('translation-manager', function ($app) {
            $manager = $app->make('Barryvdh\TranslationManager\Manager');
            return $manager;
        });

        $this->app->singleton('command.translation-manager.reset', function ($app) {
            return new Console\ResetCommand($app['translation-manager']);
        });
        $this->commands('command.translation-manager.reset');

        $this->app->singleton('command.translation-manager.import', function ($app) {
            return new Console\ImportCommand($app['translation-manager']);
        });
        $this->commands('command.translation-manager.import');

        $this->app->singleton('command.translation-manager.find', function ($app) {
            return new Console\FindCommand($app['translation-manager']);
        });
        $this->commands('command.translation-manager.find');

        $this->app->singleton('command.translation-manager.export', function ($app) {
            return new Console\ExportCommand($app['translation-manager']);
        });
        $this->commands('command.translation-manager.export');

        $this->app->singleton('command.translation-manager.clean', function ($app) {
            return new Console\CleanCommand($app['translation-manager']);
        });
        $this->commands('command.translation-manager.clean');
	}
886764
public static function register()
    {
        \Deployer\set('release_path_app', function () { return ReleaseConfig::getReleasePathAppDir(); });
        \Deployer\set('shared_path_app', function () { return ReleaseConfig::getSharedPathAppDir(); });

        \Deployer\set('release_name', function () { return GetReleasesNameService::execute(); });
        \Deployer\set('releases_list', function () { return GetReleasesListService::execute(); });
    }