Register the commands.

@return void
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');
    }
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]);
    }
220401
protected function registerCustomCommands()
    {
        // Keep the core default commands to have the HelpCommand
        // which is used when using the --help option
        $defaultCommands = parent::getDefaultCommands();

        // Automatically register commands by scanning namespaces for a 'DroidPlugin' class.
        //print_r($this->autoLoader);
        $prefixes = $this->autoLoader->getPrefixesPsr4();

        foreach ($prefixes as $namespace => $paths) {
            $className = $namespace . 'DroidPlugin';
            if (class_exists($className)) {
                $plugin = new $className($this);
                $commands = $plugin->getCommands();
                foreach ($commands as $command) {
                    $this->add($command);
                }
            }
        }

        foreach ($this->all() as $command) {
            if (method_exists($command, 'setInventory')) {
                $command->setInventory($this->inventory);
            }
        }

        if ($this->hasProject()) {
            $runner = new TaskRunner(
                $this,
                $this->transformer,
                new LoggerFactory,
                new ExpressionLanguage,
                $this->buildLegacyTransformer()
            );
            $enabler = $this->configureHostEnabler();
            if (! $enabler) {
                # TODO output a warning about not being able to run remote cmds
            } else {
                $runner->setEnabler($enabler);
            }
            foreach ($this->getProject()->getTargets() as $target) {
                $command = new BaseTargetCommand;
                $command->setName($target->getName());
                $command->setDescription("Run target: " . $target->getName());
                $command->setTarget($target->getName());
                $command->setTaskRunner($runner);
                foreach ($target->getArguments() as $argument) {

                    $required = InputArgument::OPTIONAL;
                    if ($argument->getRequired()) {
                        $required = InputArgument::REQUIRED;
                    }

                    $command->addArgument(
                        $argument->getName(),
                        $required,
                        $argument->getDescription()
                    );
                }
                $this->add($command);
            }
        }
    }
1287594
protected function registerConsoleCommands()
    {
        $this->app->singleton('cms.commands.core-menu-show', Commands\ShowMenu::class);
        $this->app->singleton('cms.commands.core-menu-cache', Commands\CacheMenu::class);
        $this->app->singleton('cms.commands.core-menu-clear', Commands\ClearMenuCache::class);
        $this->app->singleton('cms.commands.core-modules-show', Commands\ShowModules::class);

        $this->commands([
            'cms.commands.core-menu-show',
            'cms.commands.core-menu-cache',
            'cms.commands.core-menu-clear',
            'cms.commands.core-modules-show',
        ]);

        return $this;
    }
968346
public function register()
	{
		if ($this->registerOnlyForConsole && !$this->app->runningInConsole()) {
			return;
		}

		$this->registerCommands($this->commands);
	}
210531
public function registerCommands()
	{
		$this->app->bindShared('command.cache.clear', function($app)
		{
			return new Console\ClearCommand($app['cache'], $app['files']);
		});

		$this->commands('command.cache.clear');
	}
1289357
public function register()
	{
		$this->app->bindShared('command.up', function($app)
		{
			return new UpCommand;
		});

		$this->app->bindShared('command.down', function($app)
		{
			return new DownCommand;
		});

		$this->commands('command.up', 'command.down');
	}
126657
protected function registerConsoleCommands(): void
    {
        if ($this->app->runningInConsole()) {
            $this->app->bind('command.ban:delete-expired', DeleteExpiredBans::class);

            $this->commands([
                'command.ban:delete-expired',
            ]);
        }
    }
1275974
protected function registerCommands()
    {
        if ($this->app->runningInConsole()) {
            $this->commands([
                ModulesCommand::class,
                ModelsCommand::class,
                EnumsCommand::class,
                RequestsCommand::class,
                MakeModuleCommand::class,
                VersionCommand::class
            ]);
        }
    }
300650
public function register()
    {
        $this->commands([
            Commands\SetEnv::class,
            Commands\GetEnv::class,
            Commands\DeleteEnv::class,
            Commands\ListEnv::class,
        ]);
    }
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'
        ]);
    }
550315
public function register()
  {
    $listeners = $this->app['config']->get('commander::listeners');
    $namespace = $this->app['config']->get('commander::listener_namespace');

    foreach($listeners as $listener)
    {
      $this->app['events']->listen($namespace . '.*', $listener);
    }
  }
212778
protected function registerCommands()
    {
        $this->add(new \Daedalus\Command\DumpContainerCommand($this->kernel->getContainer()));
        $this->add(new \Daedalus\Command\HelpCommand($this->kernel->getContainer()));
    }
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'
        ]);
    }
108268
public function registerCommands()
    {
        $commands = (array) $this->get('console.commands');

        foreach ($commands as $command) {
            if ($command === false) {
                continue;
            }

            if (is_string($command)) {
                $command = $this->container->createObject($command);
            }

            $this->addCommand($command);
        }
    }
1102720
public function registerConsoleCommands()
    {
        $this->commands([
            \Plank\Mediable\Commands\ImportMediaCommand::class,
            \Plank\Mediable\Commands\PruneMediaCommand::class,
            \Plank\Mediable\Commands\SyncMediaCommand::class,
        ]);
    }
1078669
public function registerCommands(array $commands)
    {
        foreach ($commands as $command) {
            $instance = $this->app->make($command);

            $instance->boot($this->app);

            $this->addCommand($instance->signature, [$instance, 'register'], [
                'shortdesc' => $instance->description,
            ]);
        }
    }