Register the credits class.

@return void
489434
protected function registerCredits()
    {
        $this->app->singleton(CreditsContract::class, function ($app) {
            $cache = $app['cache.store'];

            return new Credits($cache);
        });
    }
45669
public function register()
    {
        
          if ($this->app->runningInConsole()) {
                $this->commands([
                    Commands\CrudCommand::class,
                    Commands\CrudControllerCommand::class,
                    Commands\CrudModelCommand::class,
                    Commands\CrudMigrationCommand::class,
                    Commands\CrudViewCommand::class,
                    Commands\PivotMigrationCommand::class,
                    
                ]);
            }

     }
760769
protected function registerCredentials()
    {
        $this->app->singleton('credentials', function ($app) {
            $sentry = $app['sentry'];
            $decorator = $app->make(PresenterDecorator::class);

            return new Credentials($sentry, $decorator);
        });

        $this->app->alias('credentials', Credentials::class);
    }
393617
public function register()
    {
        // register class aliases
        $loader = AliasLoader::getInstance();
        $loader->alias('PageBuilder', PageBuilderFacade::class);

        // register container aliases
        $this->app->alias('pageBuilder', PageBuilderFactory::class);
        $this->app->alias('pageBuilder', PageBuilder::class);
    }
1086427
protected function registerClassAliases(): void
	{
		$aliases = $this->config->get('application.class_aliases');

		if(!empty($aliases))
		{
			$aliasLoader = new AliasLoader($aliases);

			spl_autoload_register([$aliasLoader, 'load']);
		}
	}
1233556
public function registerFacade()
    {
        $this->app->booting(function () {
            $loader = \Illuminate\Foundation\AliasLoader::getInstance();
            $loader->alias('VatCalculator', 'Mpociot\VatCalculator\Facades\VatCalculator');
        });
    }
428284
public function register()
    {
        $loader = AliasLoader::getInstance();

        // Register aliases
        foreach ($this->getAliases() as $alias => $class) {
            $loader->alias($alias, $class);
        }

        // Register service containers
        foreach ($this->getServiceContainers() as $abstract => $concrete) {
            $this->app->singleton($abstract, $concrete);
        }
    }
968036
public function register()
    {
        $this->app->bind(InstallationContract::class, function ($app) {
            return new Installation();
        });

        $this->app->bind(RequirementContract::class, function ($app) {
            $requirement = new Requirement();

            $this->addDefaultSpecifications($requirement);

            return $requirement;
        });

        $this->registerRedirection();
    }
309770
public function register()
    {
        $this->app->singleton('themes.view.finder', function ($app) {
            $finder   = new ThemeViewFinder($app['files'], $app['config']['view.paths']);
            $basePath = config('themes.path.frontend', base_path('themes/frontend'));
            $theme    = config('themes.frontend', 'default');
            $finder->setBasePath($basePath . DIRECTORY_SEPARATOR . $theme);

            return $finder;
        });

        $this->app->singleton('themes', function () {
            return new CollectionRepository(new Finder, $this->app['config']);
        });

        $this->app->alias('themes', Repository::class);
    }
400216
public function register()
    {
        foreach ($this->getReferencesClasses() as $references_class) {
            $this->app->singleton($references_class, function (Application $app) use ($references_class) {
                return $this->bootUpReferenceInstance($references_class, $app);
            });
        }
    }
355442
public function register()
    {
        $this->app['notes'] = $this->app->share(function () {
            $providers = array(
                'php' => new PHPLookup,
                'grep' => new GrepLookup
            );
            return new Commands\NotesCommand($providers);
        });

        $this->commands('notes');
    }
833543
protected function registerConsoleCommands()
    {
        $this->commands(AssetCommand::class);
        $this->commands(ThemeCommand::class);
        $this->commands(InstallCommand::class);
        $this->commands(GenerateDocumentationCommand::class);
    }
975539
public static function register()
	{
		$class = new self();
		Events::addListener(array($class, 'screenLogEventListener'), 'screenLogEvent', EventPriority::NORMAL);
		$bar = Debugger::getBar();
		$bar->addPanel($class);
	}
663366
public function register() {

		$this->app->bind( Attributes::class, Attr::class );

		$this->app->alias( Attributes::class, 'attr' );
	}
238992
public function register()
    {
        $this->registerAliases();

        $this->registerJwTProvider();
        $this->registerAuthProvider();
        $this->registerStorageProvider();
        $this->registerJwTBlacklist();

        $this->registerManager();
        $this->registerTokenParser();

        $this->registerJwT();
        $this->registerJwTAuth();
        $this->registerPayloadValidator();
        $this->registerClaimFactory();
        $this->registerPayloadFactory();
        $this->registerJwTCommand();

        $this->commands('afroware.jwT.secret');
    }
1076114
public function register()
    {
        $this->mergeConfigFrom(
            __DIR__.'/../config/hstcms.php', 'hstcms'
        );
        $this->app->register(RouteServiceProvider::class);
        $this->app->register(HelperServiceProvider::class);
        $this->app->register(ConsoleServiceProvider::class);
        $this->app->register(LibrariesServiceProvider::class);
        $this->app->register(RepositoryServiceProvider::class);
        $this->app->register(MiddlewareServiceProvider::class);
        $this->app->register(GeneratorServiceProvider::class);

        $this->app->singleton('hstcms', function ($app) {
            $repository = $app->make(Repository::class);
            return new Hstcms($app, $repository);
        });
    }
691086
public function registerCommands()
	{
		$this->app->singleton('command.cache.clear', function($app)
		{
			return new ClearCommand($app['cache']);
		});

		$this->app->singleton('command.cache.table', function($app)
		{
			return new CacheTableCommand($app['files'], $app['composer']);
		});

		$this->commands('command.cache.clear', 'command.cache.table');
	}