Register the Horizon Artisan commands.

@return void
170236
protected function registerCommands()
    {
        if ($this->app->runningInConsole()) {
            $this->commands([
                Console\InstallCommand::class,
                Console\AssetsCommand::class,
                Console\HorizonCommand::class,
                Console\ListCommand::class,
                Console\PurgeCommand::class,
                Console\PauseCommand::class,
                Console\ContinueCommand::class,
                Console\StatusCommand::class,
                Console\SupervisorCommand::class,
                Console\SupervisorsCommand::class,
                Console\TerminateCommand::class,
                Console\TimeoutCommand::class,
                Console\WorkCommand::class,
            ]);
        }

        $this->commands([Console\SnapshotCommand::class]);
    }
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));
    }
224318
protected function registerCommands()
    {
        if ($this->app->runningInConsole()) {
            $this->commands([
                Console\AlphabetGenerateCommand::class,
                Console\OptimusGenerateCommand::class,
            ]);
        }
    }
944137
protected function registerCommands()
    {
        $this->app->singleton('cms.commands.models.cache-information', Commands\CacheModelInformation::class);
        $this->app->singleton('cms.commands.models.clear-information-cache', Commands\ClearModelInformationCache::class);
        $this->app->singleton('cms.commands.models.show-information', Commands\ShowModelInformation::class);
        $this->app->singleton('cms.commands.models.write-information', Commands\WriteModelInformation::class);

        $this->commands([
            'cms.commands.models.cache-information',
            'cms.commands.models.clear-information-cache',
            'cms.commands.models.show-information',
            'cms.commands.models.write-information',
        ]);

        return $this;
    }
1024472
private function registerCommands()
  {
    // Command to create a new OAuth client
    $this->app['command.api.newOAuthClient'] = $this->app->share(function ($app) {
      return $app->make('Sule\Api\Commands\NewOAuthClient');
    });

    // Command to create a new OAuth scope
    $this->app['command.api.newOAuthScope'] = $this->app->share(function ($app) {
      return $app->make('Sule\Api\Commands\NewOAuthScope');
    });

    // Command to clean expired OAuth tokens
    $this->app['command.api.cleanExpiredTokens'] = $this->app->share(function ($app) {
      return $app->make('Sule\Api\Commands\CleanExpiredTokens');
    });

    $this->commands(
      'command.api.newOAuthClient', 
      'command.api.newOAuthScope', 
      'command.api.cleanExpiredTokens'
    );
  }
182550
private function registerCommands()
    {
        $commands = [
            'arbory.seed' => SeedCommand::class,
            'arbory.install' => InstallCommand::class,
            'arbory.generator' => GeneratorCommand::class,
            'arbory.generate' => GenerateCommand::class
        ];

        foreach( $commands as $containerKey => $commandClass )
        {
            $this->registerCommand( $containerKey, $commandClass );
        }
    }
374507
protected function registerMigrateMakeCommand(): void
    {
        $this->app->singleton('command.migrate.make', function ($app) {
            // Once we have the migration creator registered, we will create the command
            // and inject the creator. The creator is responsible for the actual file
            // creation of the migrations, and may be extended by these developers.
            $creator = $app['migration.creator'];

            $composer = $app['composer'];

            return new MigrateMakeCommand($creator, $composer);
        });
    }
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'
        );
    }
547549
protected function registerCommands()
    {
        $this->app['iverberk.larasearch.commands.reindex'] = $this->app->share(function ($app)
        {
            return new ReindexCommand();
        });

        $this->app['iverberk.larasearch.commands.paths'] = $this->app->share(function ($app)
        {
            return new PathsCommand();
        });

        $this->commands('iverberk.larasearch.commands.reindex');
        $this->commands('iverberk.larasearch.commands.paths');
    }
1115956
protected function registerWorkCommand()
    {
        $this->app->extend('command.queue.work', function () {
            if ($this->eye->laravelVersionIs('>=', '5.3.0')) {
                return new WorkCommand($this->app['queue.worker']);
            } else {
                return new LegacyWorkCommand($this->app['queue.worker']);
            }
        });
    }
1165205
private function registerCommands()
    {
        $this->app['commands.drawbridge.migrations'] = $this->app->share(function($app)
        {
            return new MigrationsCommand($app);
        });

        $this->commands(
            array(
                 'commands.drawbridge.migrations'
            )
        );
    }
1019212
protected function registerMigrateCommand()
    {
        $this->app->singleton('command.module.migrate', function ($app) {
            return new \Caffeinated\Modules\Console\Commands\ModuleMigrateCommand($app['migrator'], $app['modules']);
        });

        $this->commands('command.module.migrate');
    }
861032
protected function registerCommands()
    {
        $this->commands([
            CheckForUpdate::class,
        ]);

        // Register custom commands from config
        collect(config('self-update.artisan_commands.pre_update'))->each(function ($command) {
            $this->commands([$command['class']]);
        });
        collect(config('self-update.artisan_commands.post_update'))->each(function ($command) {
            $this->commands([$command['class']]);
        });
    }
754433
private function registerAliases()
    {
        $aliasLoader = AliasLoader::getInstance();
//        $aliasLoader->alias( 'TranslationCache', \Waavi\Translation\Facades\TranslationCache::class );
        $aliasLoader->alias( 'Activation', \Cartalyst\Sentinel\Laravel\Facades\Activation::class );
        $aliasLoader->alias( 'Reminder', \Cartalyst\Sentinel\Laravel\Facades\Reminder::class );
        $aliasLoader->alias( 'Sentinel', \Cartalyst\Sentinel\Laravel\Facades\Sentinel::class );
        $aliasLoader->alias( 'GlideImage', \Roboc\Glide\Support\Facades\GlideImage::class );
        $aliasLoader->alias( 'Excel', \Maatwebsite\Excel\Facades\Excel::class );
    }
231328
private function registerArtisanCommands()
    {
        // Register the Scaffold command
        $this->app->singleton('centaur.scaffold', function ($app) {
            return new CentaurScaffold(
                $app->make('files')
            );
        });
        $this->commands('centaur.scaffold');

        // Register the Spruce command
        $this->app->singleton('centaur.spruce', function ($app) {
            return new CentaurSpruce(
                $app->make('files')
            );
        });
        $this->commands('centaur.spruce');
    }
495590
private function registerArtisanCommands() {
        $this->commands([
            \BackupManager\Laravel\Laravel4DbBackupCommand::class,
            \BackupManager\Laravel\Laravel4DbRestoreCommand::class,
            \BackupManager\Laravel\Laravel4DbListCommand::class
        ]);
    }
1360039
protected function registerCommands(): void
    {
        $this->app->singleton('command.couchbase.indexes', function ($app) {
            return new IndexFinderCommand($app['Illuminate\Database\DatabaseManager']);
        });
        $this->app->singleton('command.couchbase.primary.index.create', function ($app) {
            return new PrimaryIndexCreatorCommand($app['Illuminate\Database\DatabaseManager']);
        });
        $this->app->singleton('command.couchbase.primary.index.drop', function ($app) {
            return new PrimaryIndexRemoverCommand($app['Illuminate\Database\DatabaseManager']);
        });
        $this->app->singleton('command.couchbase.index.create', function ($app) {
            return new IndexCreatorCommand($app['Illuminate\Database\DatabaseManager']);
        });
        $this->app->singleton('command.couchbase.index.drop', function ($app) {
            return new IndexRemoverCommand($app['Illuminate\Database\DatabaseManager']);
        });
        $this->app->singleton('command.couchbase.queue.index.create', function ($app) {
            return new QueueCreatorCommand($app['Illuminate\Database\DatabaseManager']);
        });
        $this->app->singleton('command.couchbase.design.document.create', function ($app) {
            return new DesignCreatorCommand(
                $app['Illuminate\Database\DatabaseManager'],
                $app['config']->get('couchbase.design')
            );
        });
        $this->commands([
            'command.couchbase.indexes',
            'command.couchbase.primary.index.create',
            'command.couchbase.primary.index.drop',
            'command.couchbase.index.create',
            'command.couchbase.index.drop',
            'command.couchbase.queue.index.create',
            'command.couchbase.design.document.create',
        ]);
    }