Register the artisan commands.

@return void
495590
private function registerArtisanCommands() {
        $this->commands([
            \BackupManager\Laravel\Laravel4DbBackupCommand::class,
            \BackupManager\Laravel\Laravel4DbRestoreCommand::class,
            \BackupManager\Laravel\Laravel4DbListCommand::class
        ]);
    }
520525
public function register()
    {
        $this->app->singleton('artisan', function ($app) {
            $artisan = new Artisan($app, $app->make('events'), $app->version());
            $commands = $this->app->runningInPhar() ? [] : $this->commands;
            $artisan->resolveCommands($commands);

            return $artisan;
        });
    }
876648
public function register()
    {
        $this->commands([
            \WebEd\Base\Console\Commands\InstallCmsCommand::class,
            \WebEd\Base\Console\Commands\UpdateCmsCommand::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');
    }
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();
        });
    }
1363942
protected function registerMigrateMakeCommand()
    {
        Zilf::$container->register(
            '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);
            }
        );
    }
972153
public function registerCommands()
    {
        if (! $this->app->runningInConsole()) {
            return;
        }

        foreach ($this->commands as $command) {
            $this->commands($command);
        }
    }
843591
protected function registerTinkerCommand(): void
    {
        $this->app->singleton('orchestra.commands.tenanti.tinker', function (Application $app) {
            return new TinkerCommand($app->make('orchestra.tenanti'));
        });
    }
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'
    );
  }
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'
        ]);
    }
731025
public function registerCommands()
    {
        $this->app->singleton('command.database.status', function ($app) {
            return new Commands\DatabaseStatusCommand();
        });

        $this->app->singleton('command.database.upgrade', function ($app) {
            return new Commands\DatabaseUpgradeCommand();
        });

        $this->app->singleton('command.database.clean', function ($app) {
            return new Commands\DatabaseCleanCommand();
        });

        $this->app->singleton('command.database.refresh', function ($app) {
            return new Commands\DatabaseRefreshCommand();
        });

        $this->app->singleton('command.database.rollback', function ($app) {
            return new Commands\DatabaseRollbackCommand();
        });

        $this->app->singleton('command.database.again', function ($app) {
            return new Commands\DatabaseAgainCommand();
        });

        $this->app->singleton('command.database.seed', function ($app) {
            return new Commands\DatabaseSeedCommand();
        });

        $this->app->singleton('command.migration.make', function ($app) {
            return new Commands\MigrationMakeCommand();
        });

        $this->app->singleton('command.seeder.make', function ($app) {
            return new Commands\SeederMakeCommand();
        });

        $this->commands([
            'command.database.status',
            'command.database.upgrade',
            'command.database.clean',
            'command.database.refresh',
            'command.database.rollback',
            'command.database.again',
            'command.database.seed',
            'command.migration.make',
            'command.seeder.make',
        ]);
    }
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,
            ]);
    }
492137
private function registerArtisanCommands() {
        $this->commands([
            \BackupManager\Laravel\Laravel50DbBackupCommand::class,
            \BackupManager\Laravel\Laravel50DbRestoreCommand::class,
            \BackupManager\Laravel\Laravel50DbListCommand::class,
        ]);
    }
137789
public function register()
    {
        $this->commands('Kris\LaravelFormBuilder\Console\FormMakeCommand');

        $this->registerFormHelper();

        $this->app->bindShared('laravel-form-builder', function ($app) {

            return new FormBuilder($app, $app['laravel-form-helper']);
        });
    }
153382
protected function registerCommands(array $commands)
    {
        foreach (array_keys($commands) as $command) {
            call_user_func_array([$this, "register{$command}Command"], []);
        }

        $this->commands(array_values($commands));
    }
980870
protected function registerMakeCommand(): void
    {
        $this->app->singleton('orchestra.tenanti.creator', function (Application $app) {
            return new Creator($app->make('files'));
        });

        $this->app->singleton('orchestra.commands.tenanti.make', function (Application $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.
            return new MigrateMakeCommand(
                $app->make('orchestra.tenanti'),
                $app->make('orchestra.tenanti.creator'),
                $app->make('composer')
            );
        });
    }