Register the configuration publish console command.

@return void
160182
protected function registerConfigPublishCommand(): void
    {
        $this->app->singleton('command.config.publish', function (Application $app) {
            return new ConfigPublishCommand($app->make('config.publisher'));
        });
    }
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'
        ]);
    }
171035
protected function configure()
    {
        $this->addArgument(
            'command-to-run',
            InputArgument::REQUIRED,
            'Command to run'
        );
        $this->addOption(
            'log',
            null,
            Option::VALUE_REQUIRED,
            'Log to file'
        );
        $this->addOption(
            'stage',
            null,
            Option::VALUE_REQUIRED,
            'Stage to deploy'
        );
        $this->addOption(
            'roles',
            null,
            Option::VALUE_REQUIRED,
            'Roles to deploy'
        );
        $this->addOption(
            'hosts',
            null,
            Option::VALUE_REQUIRED,
            'Host to deploy, comma separated, supports ranges [:]'
        );
    }
742040
private function registerPublishing()
    {
        if ($this->app->runningInConsole()) {
            $this->publishes([
                __DIR__.'/Storage/migrations' => database_path('migrations'),
            ], 'telescope-migrations');

            $this->publishes([
                __DIR__.'/../public' => public_path('vendor/telescope'),
            ], 'telescope-assets');

            $this->publishes([
                __DIR__.'/../config/telescope.php' => config_path('telescope.php'),
            ], 'telescope-config');

            $this->publishes([
                __DIR__.'/../stubs/TelescopeServiceProvider.stub' => app_path('Providers/TelescopeServiceProvider.php'),
            ], 'telescope-provider');
        }
    }
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;
        });
    }
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;
        });
    }
1075345
public function register()
    {
        $this->app->singleton('jiyis.publish', function ($app) {
            return new GeneratorPublishCommand();
        });

        $this->app->singleton('jiyis.api', function ($app) {
            return new APIGeneratorCommand();
        });

        $this->app->singleton('jiyis.scaffold', function ($app) {
            return new ScaffoldGeneratorCommand();
        });

        $this->app->singleton('jiyis.publish.layout', function ($app) {
            return new LayoutPublishCommand();
        });

        $this->app->singleton('jiyis.publish.templates', function ($app) {
            return new PublishTemplateCommand();
        });

        $this->app->singleton('jiyis.api_scaffold', function ($app) {
            return new APIScaffoldGeneratorCommand();
        });

        $this->app->singleton('jiyis.migration', function ($app) {
            return new MigrationGeneratorCommand();
        });

        $this->app->singleton('jiyis.model', function ($app) {
            return new ModelGeneratorCommand();
        });

        $this->app->singleton('jiyis.repository', function ($app) {
            return new RepositoryGeneratorCommand();
        });

        $this->app->singleton('jiyis.api.controller', function ($app) {
            return new APIControllerGeneratorCommand();
        });

        $this->app->singleton('jiyis.api.requests', function ($app) {
            return new APIRequestsGeneratorCommand();
        });

        $this->app->singleton('jiyis.api.tests', function ($app) {
            return new TestsGeneratorCommand();
        });

        $this->app->singleton('jiyis.scaffold.controller', function ($app) {
            return new ControllerGeneratorCommand();
        });

        $this->app->singleton('jiyis.scaffold.requests', function ($app) {
            return new RequestsGeneratorCommand();
        });

        $this->app->singleton('jiyis.scaffold.views', function ($app) {
            return new ViewsGeneratorCommand();
        });

        $this->app->singleton('jiyis.rollback', function ($app) {
            return new RollbackGeneratorCommand();
        });

        $this->commands([
            'jiyis.publish',
            'jiyis.api',
            'jiyis.scaffold',
            'jiyis.api_scaffold',
            'jiyis.publish.layout',
            'jiyis.publish.templates',
            'jiyis.migration',
            'jiyis.model',
            'jiyis.repository',
            'jiyis.api.controller',
            'jiyis.api.requests',
            'jiyis.api.tests',
            'jiyis.scaffold.controller',
            'jiyis.scaffold.requests',
            'jiyis.scaffold.views',
            'jiyis.rollback',
        ]);
    }
1272585
protected function registerConfig()
    {
        $config = $this->config = app('PragmaRX\Tddd\Package\Services\Config');

        $this->app->singleton('tddd.config', function () use ($config) {
            return $config;
        });
    }
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);
        });
    }
517145
public function register()
    {
        $this->app->bindShared('command.session.database', function($app)
        {
            return new Console\SessionTableCommand($app['files']);
        });

        $this->commands('command.session.database');
    }
745697
public function register( $args = [ ] ) {
		foreach ( $this->getConfigKeys() as $contentType ) {
			$this->registerContentType(
				$contentType,
				$this->config->getSubConfig( $contentType )
			);
		}
	}
135678
protected function registerLockdownConfiguration()
    {
        $this->publishes(
            [
                __DIR__ . $this->modelsConfigPath    =>
                    config_path('lockdown.php'),
            ],
            'config'
        );

        $this->mergeConfigFrom(
            __DIR__ . $this->modelsConfigPath,
            'lockdown'
        );
    }
1307895
public function register()
    {
        $this->publishes([
            __DIR__ . '/config/setting.php' => config_path('setting.php'),
        ]);

        $this->app->bind(['setting' => 'Thetispro\Setting\Setting'],
                function($app) {
            return new Setting(
                    config('setting.path'), config('setting.filename'),
                    config('setting.fallback') ? new LaravelFallbackInterface() : null);
        }); 
    }
297351
public function register()
    {
        $this->registerFileConfig();
        $this->registerDatabaseConfig();

        // Bind the concrete types
        $this->app->bind('Concrete\Core\Config\Repository\Repository', 'config');
        $this->app->bind('Illuminate\Config\Repository', 'Concrete\Core\Config\Repository\Repository');
    }
142912
protected function registerConfig() {
        $config = new Configuration($this->configFile);
        $this->container->set('config', function() use ($config) {
                return $config;
        });
    }
534296
protected function registerPublishes(): void
    {
        $this->publishes([
            __DIR__.'/../../config/rating.php' => config_path('rating.php'),
        ], 'config');

        if ($this->app->runningInConsole()) {
            if (! class_exists('CreateRatingTables')) {
                $timestamp = date('Y_m_d_His', time());
                $this->publishes([
                    __DIR__.'/../../database/migrations/create_rating_tables.php.stub' => database_path('migrations/'.$timestamp.'_create_rating_tables.php'),
                ], 'migrations');
            }
        }
    }
846752
public function register ()
    {
        //configs
        $this->mergeConfigFrom(
            __DIR__ . '/Config/categories.php' , 'categories'
        );
        $this->publishes([
            __DIR__ . '/Config/categories.php' => config_path('categories.php') ,
        ] , 'catconfig');

        // publish lang
        $this->publishes([
            __DIR__ . '/Lang/' => resource_path('lang/vendor/categories') ,
        ]);

    }