Register console commands.

@return void
766367
protected function registerCommands(): void
    {
        // Register artisan commands
        foreach ($this->commands as $key => $value) {
            $this->app->singleton($value, $key);
        }

        $this->commands(array_values($this->commands));
    }
200888
public function register()
	{
		$this->app->singleton('command.session.database', function($app)
		{
			return new Console\SessionTableCommand($app['files'], $app['composer']);
		});

		$this->commands('command.session.database');
	}
124695
private function registerCommands()
    {
        $this->app['command.assetprocessor.cleanup'] = $this->app->share(function($app)
        {
            return new CleanupCommand($app);
        });

        $this->commands(
            'command.assetprocessor.cleanup'
        );

        $this->app['command.assetprocessor.process'] = $this->app->share(function($app)
        {
            return new ProcessCommand($app);
        });

        $this->commands(
            'command.assetprocessor.process'
        );
    }
363930
private function registerCommands()
    {
        // monashee:backup
        $this->app['command.monashee.backup'] = $this->app->share(function() {
            return $this->app->make('Monashee\Backup\Commands\MonasheeBackup');
        });

        $this->commands('command.monashee.backup');
    }
334091
protected function registerCommands()
    {
        $this->app->bind('command.log-reader.delete', 'Jackiedo\LogReader\Console\Commands\LogReaderDeleteCommand');
        $this->app->bind('command.log-reader.detail', 'Jackiedo\LogReader\Console\Commands\LogReaderDetailCommand');
        $this->app->bind('command.log-reader.file-list', 'Jackiedo\LogReader\Console\Commands\LogReaderFileListCommand');
        $this->app->bind('command.log-reader.get', 'Jackiedo\LogReader\Console\Commands\LogReaderGetCommand');
        $this->app->bind('command.log-reader.remove-file', 'Jackiedo\LogReader\Console\Commands\LogReaderRemoveFileCommand');

        $this->commands('command.log-reader.delete');
        $this->commands('command.log-reader.detail');
        $this->commands('command.log-reader.file-list');
        $this->commands('command.log-reader.get');
        $this->commands('command.log-reader.remove-file');
    }
1144442
private function registerArtisanCommands() {
        $this->commands([
            \BackupManager\Laravel\Laravel5DbBackupCommand::class,
            \BackupManager\Laravel\Laravel5DbRestoreCommand::class,
            \BackupManager\Laravel\Laravel5DbListCommand::class,
        ]);
    }
559863
protected function registerConsoleCommands()
    {
        $this->commands([
            InfoCommand::class,
            SchemaCreateCommand::class,
            SchemaUpdateCommand::class,
            SchemaDropCommand::class,
            SchemaValidateCommand::class,
            ClearMetadataCacheCommand::class,
            ClearResultCacheCommand::class,
            ClearQueryCacheCommand::class,
            EnsureProductionSettingsCommand::class,
            GenerateProxiesCommand::class
        ]);
    }
299183
public function register()
    {
        $this->app->singleton('command.queue.table', function ($app) {
            return new TableCommand($app['files']);
        });

        $this->app->bindShared('command.queue.failed', function()
        {
            return new ListFailedCommand;
        });

        $this->app->bindShared('command.queue.retry', function()
        {
            return new RetryCommand;
        });

        $this->app->bindShared('command.queue.forget', function()
        {
            return new ForgetFailedCommand;
        });

        $this->app->bindShared('command.queue.flush', function()
        {
            return new FlushFailedCommand;
        });

        $this->app->bindShared('command.queue.failed-table', function($app)
        {
            return new FailedTableCommand($app['files']);
        });

        $this->commands(
            'command.queue.table', 'command.queue.failed', 'command.queue.retry',
            'command.queue.forget', 'command.queue.flush', 'command.queue.failed-table'
        );
    }
262607
protected function registerConsoleCommands()
    {
        $this->commands([
            InfoCommand::class,
            SchemaCreateCommand::class,
            SchemaUpdateCommand::class,
            SchemaDropCommand::class,
            SchemaValidateCommand::class,
            ClearMetadataCacheCommand::class,
            ClearResultCacheCommand::class,
            ClearQueryCacheCommand::class,
            EnsureProductionSettingsCommand::class,
            GenerateProxiesCommand::class,
            ConvertConfigCommand::class,
            MappingImportCommand::class,
            GenerateEntitiesCommand::class,
            GenerateRepositoriesCommand::class,
            ConvertMappingCommand::class,
            DumpDatabaseCommand::class
        ]);
    }
472116
protected function initialiseCommands()
    {
        $modules = $this->kernel->getModules();

        foreach ($modules as $module) {
            if ( ! $module instanceof ConsoleModuleInterface) {
                continue;
            }

            $module->registerCommands($this);
        }
    }
506278
public function registerCustomCommands()
    {
        try {
            $this->readCustomCommandsFromConfig();
        } catch (ConfigurationException $e) {
            if ($e->getCode() === 404) {
                return;
            }
            $this->renderException($e, new ConsoleOutput());
            exit(1);
        } catch (\Exception $e) {
            $this->renderException($e, new ConsoleOutput());
            exit(1);
        }
    }
561889
public function register()
    {
        $this->app->singleton('le-admin.command.instance.new', function ($app) {
            return $app->make('Lokielse\AdminGenerator\Console\Commands\CreateInstanceCommand');
        });

        $this->app->singleton('le-admin.command.entity.new', function ($app) {
            return $app->make('Lokielse\AdminGenerator\Console\Commands\CreateEntityCommand');
        });

        $this->commands([
            'le-admin.command.instance.new',
            'le-admin.command.entity.new'
        ]);
    }
1222032
public function registerCommands()
	{
		$this->app['foruminstallcommand'] = $this->app->share(function($app)
        {
            return new InstallCommand;
        });
		$this->commands('foruminstallcommand');
	}
1188401
public function registerConsole()
    {
        $this->commands(TypeMakeCommand::class);
        $this->commands(QueryMakeCommand::class);
        $this->commands(MutationMakeCommand::class);
    }
237569
public function registerCommands()
    {
        foreach ($this->commandsStack as $key => $command) {
            $this->resolveConsoleCommand('\\'.$command);
        }

        return $this;
    }
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'
        ]);
    }
370159
public function register()
    {
        $this->commands(MigrateCommand::class);
        $this->commands(ModelsCommand::class);
        $this->commands(SeedCommand::class);

        $this->mergeConfigFrom(__DIR__ . '/../../config/config.php', 'db-exporter');
    }