Register all the commands
337951
private void registerCommands() {
        commandManager.setWrongLevelMsg(languageManager.getString("command_disabled_setup_mode"));
        SubCommand money = new SubCommand("money", commandManager, null, 1);
        money.addCommand("", new MainCommand());
        money.addCommand("all", new AllCommand());
        money.addCommand("pay", new PayCommand());
        money.addCommand("give", new GiveCommand());
        money.addCommand("take", new TakeCommand());
        money.addCommand("set", new SetCommand());
        money.addCommand("delete", new DeleteCommand());
        money.addCommand("create", new CreateCommand());
        money.addCommand("balance", new BalanceCommand());
        money.addCommand("top", new TopCommand());
        money.addCommand("exchange", new ExchangeCommand());
        money.addCommand("infinite", new InfiniteCommand());
        money.addCommand("log", new LogCommand());
        commandManager.registerMainCommand("money", money);

        SubCommand bank = new SubCommand("bank", commandManager, null, 1);
        bank.addCommand("create", new BankCreateCommand());
        bank.addCommand("balance", new BankBalanceCommand());
        bank.addCommand("deposit", new BankDepositCommand());
        bank.addCommand("withdraw", new BankWithdrawCommand());
        bank.addCommand("set", new BankSetCommand());
        bank.addCommand("give", new BankGiveCommand());
        bank.addCommand("take", new BankTakeCommand());
        bank.addCommand("perm", new BankPermCommand());
        bank.addCommand("list", new BankListCommand());
        bank.addCommand("delete", new BankDeleteCommand());
        bank.addCommand("ignoreacl", new BankIgnoreACLCommand());
        commandManager.registerMainCommand("bank", bank);

        SubCommand ccsetup = new SubCommand("ccsetup", commandManager, null, 0);
        ccsetup.addCommand("", new NewSetupMainCommand());
        ccsetup.addCommand("database", new NewSetupDatabaseCommand());
        ccsetup.addCommand("currency", new NewSetupCurrencyCommand());
        ccsetup.addCommand("basic", new NewSetupBasicCommand());
        ccsetup.addCommand("convert", new NewSetupConvertCommand());
        commandManager.registerMainCommand("ccsetup", ccsetup);

        SubCommand currency = new SubCommand("currency", commandManager, null, 1);
        currency.addCommand("add", new CurrencyAddCommand());
        currency.addCommand("delete", new CurrencyDeleteCommand());
        currency.addCommand("edit", new CurrencyEditCommand());
        currency.addCommand("info", new CurrencyInfoCommand());
        currency.addCommand("default", new CurrencyDefaultCommand());
        currency.addCommand("exchange", new CurrencyExchangeCommand());
        currency.addCommand("rates", new CurrencyRatesCommand());
        currency.addCommand("list", new CurrencyListCommand());
        commandManager.registerMainCommand("currency", currency);

        SubCommand configCommand = new SubCommand("craftconomy", commandManager, null, 1);
        configCommand.addCommand("holdings", new ConfigHoldingsCommand());
        configCommand.addCommand("bankprice", new ConfigBankPriceCommand());
        configCommand.addCommand("format", new ConfigFormatCommand());
        configCommand.addCommand("clearlog", new ConfigClearLogCommand());
        configCommand.addCommand("reload", new ConfigReloadCommand());
        commandManager.registerMainCommand("craftconomy", configCommand);

        SubCommand ccgroup = new SubCommand("ccgroup", commandManager, null, 1);
        ccgroup.addCommand("create", new GroupCreateCommand());
        ccgroup.addCommand("addworld", new GroupAddWorldCommand());
        ccgroup.addCommand("delworld", new GroupDelWorldCommand());
        commandManager.registerMainCommand("ccgroup", ccgroup);

        SubCommand payCommand = new SubCommand("pay", commandManager, null, 1);
        payCommand.addCommand("", new PayCommand());
        commandManager.registerMainCommand("pay", payCommand);
    }
829316
private function registerArtisanCommands() {
        $this->commands([
            \BackupManager\Laravel\Laravel55DbBackupCommand::class,
            \BackupManager\Laravel\Laravel55DbRestoreCommand::class,
            \BackupManager\Laravel\Laravel55DbListCommand::class,
        ]);
    }
724318
public function registerCommands() : void {
		// Register a command for basset
		$this->app->singleton('command.basset', function($app) {
			return new BuildCommand($app['basset'], $app['basset.builder'], $app['basset.builder.cleaner']);
		});

		$this->commands('command.basset');
	}
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,
            ]);
        }
    }
199565
protected function registerCommands()
    {
        $namespace    =    __NAMESPACE__ . '\\Commands\\';
        $keyPrefix    =    'lockdown.commands.';
        $commands    =    [
            $keyPrefix . 'assign-perm-user'  =>    'AssignPermissionToUser',
            $keyPrefix . 'assign-role-perm'  =>    'AssignPermissionToRole',
            $keyPrefix . 'assign-role-user'  =>    'AssignRoleToUser',
            $keyPrefix . 'create-perm'       =>    'CreatePermission',
            $keyPrefix . 'create-role'       =>    'CreateRole',
            $keyPrefix . 'delete-permission' =>    'DeletePermission',
            $keyPrefix . 'delete-role'       =>    'DeleteRole',
            $keyPrefix . 'remove-perm-user'  =>    'RemovePermissionFromUser',
            $keyPrefix . 'remove-role-perm'  =>    'RemovePermissionFromRole',
            $keyPrefix . 'remove-role-user'  =>    'RemoveRoleFromUser',
            $keyPrefix . 'show-permissions'  =>    'ShowPermissions',
            $keyPrefix . 'show-roles'        =>    'ShowRoles',
        ];

        foreach ($commands as $key => $class) {
            $this->app->bind(
                $key,
                function ($app) use ($class, $namespace) {
                    $classNamespaceFull    =    $namespace . $class;
                    return new $classNamespaceFull($app['lockdown']);
                }
            );
        }

        $this->commands(array_keys($commands));
    }
1016189
private function registerConsoleCommands()
    {
        $this->registerMakeCommand();
        $this->registerEnableCommand();
        $this->registerDisableCommand();
        $this->registerListCommand();
        $this->registerMigrateCommand();
        $this->registerMigrateRefreshCommand();
        $this->registerMakeMigrationCommand();
        $this->registerMakeRequestCommand();
        $this->registerMakeModelCommand();

        $this->commands([
            'pluggables.makeMigration',
            'pluggables.enable',
            'pluggables.disable',
            'pluggables.list',
            'pluggables.make',
            'pluggables.make.request',
            'pluggables.make.model',
            'pluggables.migrate',
            'pluggables.migrateRefresh',
        ]);
    }
876648
public function register()
    {
        $this->commands([
            \WebEd\Base\Console\Commands\InstallCmsCommand::class,
            \WebEd\Base\Console\Commands\UpdateCmsCommand::class,
        ]);
    }
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);
        }
    }
806563
protected function registerMigrateCommands()
    {
        $this->app->singleton('cms.commands.db-migrate', MigrateCommand::class);
        $this->app->singleton('cms.commands.db-migrate-install', MigrateInstallCommand::class);
        $this->app->singleton('cms.commands.db-migrate-refresh', MigrateRefreshCommand::class);
        $this->app->singleton('cms.commands.db-migrate-reset', MigrateResetCommand::class);
        $this->app->singleton('cms.commands.db-migrate-rollback', MigrateRollbackCommand::class);
        $this->app->singleton('cms.commands.db-migrate-status', MigrateStatusCommand::class);

        $this->commands([
            'cms.commands.db-migrate',
            'cms.commands.db-migrate-install',
            'cms.commands.db-migrate-reset',
            'cms.commands.db-migrate-refresh',
            'cms.commands.db-migrate-rollback',
            'cms.commands.db-migrate-status',
        ]);

        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'
    );
  }
702697
protected function registerCommands(array $commands)
	{
		if (!$this->app->runningInConsole()) {
			return;
		}

		foreach ($commands as $key => $command) {
			if (is_numeric($key)) {
				$key = Str::lower(str_replace("\\", '.', $command));
			}

			$method = "register{$command}";

			try {
				if (method_exists($this, $method)) {
					call_user_func_array([$this, $method], [$key]);
				} else {
					$this->app->singleton($key, function ($app) use ($command) {
						return $app->make($command);
					});
				}
				$this->commands($key);
			} catch (\Exception $e) {
				throw $e;
			}
		}
	}
720241
protected function registerCommands()
    {
        $this->application->addCommands([
            new BuildCommand($this->viewFactory, $this->filesystem),
            new PostCommand($this->viewFactory, $this->filesystem)
        ]);
    }
752453
def def_cmd(name=None, short=None, fn=None, usage=None, help=None):
    
    command = Command(name=name, short=short, fn=fn, usage=usage, help=help)
    Command.register(command)
327657
public function register()
    {
        $this->commands([
            Commands\DeployCommand::class,
            Commands\ListCommand::class,
            Commands\RollbackCommand::class,
            Commands\SyncCommand::class,
        ]);
    }
1102720
public function registerConsoleCommands()
    {
        $this->commands([
            \Plank\Mediable\Commands\ImportMediaCommand::class,
            \Plank\Mediable\Commands\PruneMediaCommand::class,
            \Plank\Mediable\Commands\SyncMediaCommand::class,
        ]);
    }
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');
	}
553005
protected function registerCommands()
    {
        ensure_trait_used_in_subclass_of_or_fail(self::class, $this, ServiceProvider::class);

        foreach (array_keys($this->commands) as $command) {
            $method = "register{$command}Command";
            call_user_func_array([$this, $method], []);
        }
        $this->commands(array_values($this->commands));
    }