Register the application services.
556615
public function register()
    {
        $this->app->singleton('fractal', function ($app, $arguments) {
            return fractal(...$arguments);
        });

        $this->app->alias('fractal', Fractal::class);
    }
12961
private function registerServices(): void
    {
        $services = ExchangerRegistry::getServices();

        foreach ($services as $name => $class) {
            self::register($name, $class);
        }
    }
897417
public function register()
    {
        // Register the HtmlServiceProvider
        $this->app->register(\Collective\Html\HtmlServiceProvider::class);

        // Add aliases to Form/Html Facade
        $loader = AliasLoader::getInstance();

        // Add aliases to Form/Html Facade
        $loader->alias('Form', FormFacade::class);
        $loader->alias('Html', HtmlFacade::class);

        // Add alias for datagrid
        $loader->alias('Datagrid', Datagrid::class);
    }
530708
public function register()
	{
		$this->app['db'] = function($app)
		{
			// @FIXME: this isn't pretty, but it will shim the removal of the old mysql_* calls from php
			$driver = (Config::get('dbtype') == 'mysql') ? 'pdo' : Config::get('dbtype');

			$options = [
				'driver'   => $driver,
				'host'     => Config::get('host'),
				'user'     => Config::get('user'),
				'password' => Config::get('password'),
				'database' => Config::get('db'),
				'prefix'   => Config::get('dbprefix')
			];

			return Driver::getInstance($options);
		};
	}
1306414
public function register()
    {
        $this->mergeConfigFrom(__DIR__.'/config/scms.php', 'scms');
        $this->initAliases();
        $this->app->register('Cviebrock\EloquentSluggable\SluggableServiceProvider');
        $this->app->register('SleepingOwl\Admin\AdminServiceProvider');
        $this->app->register('Illuminate\Html\HtmlServiceProvider');
        foreach($this->aliases as $alias => $class){
            $this->app->bind($alias, function($app){
                return new $app;
            });
        }
        include __DIR__ . '/routes.php';
    }
344227
public function register()
    {
        $this->mergeConfigFrom(
            __DIR__ . '/../../../config/config.php', 'laravalid'
        );

        if (!isset($this->app['html'])) {
            $this->app->singleton('html', function ($app) {
                return new HtmlBuilder($app['url'], $app['view']);
            });
        }

        $this->app->singleton('laravalid', function ($app) {
            $plugin = $app['config']['laravalid.plugin'];
            $converterClass = (strpos($plugin, '\\') === false ? 'Bllim\Laravalid\Converter\\' : '') . $plugin . '\Converter';

            /* @var $session \Illuminate\Session\Store */
            $session = $app['session.store'];
            $form = new FormBuilder($app['html'], $app['url'], $app['view'], $session->token(), new $converterClass($app), $app['request']);

            return $form->setSessionStore($session);
        });
    }
560018
protected function registerServices()
    {
        $this->app->singleton('modules', function ($app) {
            $path = $app['config']->get('modules.paths.modules');

            return new Repository($app, $path);
        });
    }
400240
protected function registerServices()
    {
        foreach (self::$diMap as $serviceKey => $serviceClass) {
            if (\is_int($serviceKey)) {
                $this->register(new $serviceClass);
            } else {
                $this[$serviceKey] = function ($c) use ($serviceClass) {
                    return new $serviceClass($c);
                };
            }
        }
    }
282527
public function register()
    {
        defined('XS_APP_ROOT') || define('XS_APP_ROOT', config_path());
        $this->app->singleton(XunsearchService::class, function ($app) {
            return new XunsearchService();
        });
        $this->app->alias(XunsearchService::class, 'xunsearch');
    }
337284
public function register()
    {
        $this->registerBindings();
        $this->app['events']->listen(BuildingSidebar::class, RegisterOrderSidebar::class);

        $this->app['events']->listen(LoadingBackendTranslations::class, function (LoadingBackendTranslations $event) {
            $event->load('orders', array_dot(trans('order::orders')));
            $event->load('orderstatuses', array_dot(trans('order::orderstatuses')));
            $event->load('transactions', array_dot(trans('order::transactions')));
            $event->load('transportations', array_dot(trans('order::transportations')));
            // append translations


        });
    }
1350706
public function register()
    {
        $this->app->bind(LoaderInterface::class, ArrayLoader::class);

        $this->registerExtensionConfig();
        $this->registerExtensionFinder();
        $this->registerExtensionManager();
        $this->registerExtensionDispatcher();
        $this->registerExtensionBootstrap();
        $this->registerComposerHandler();
        $this->registerComponentsRepository();
    }
1278929
public function register()
    {
        $this->app->singleton('orchestra.hashid', function (Application $app) {
            return new Hashids($app->make('config')->get('app.key'));
        });
    }
177595
public function register()
    {
        $this->app->singleton(Client\ApiClient::class, function () {

            $kollusApiClient = new Client\ApiClient(
                config('kollus.domain'),
                config('kollus.api_version'),
                config('kollus.language')
            );

            $serviceAccount = new Container\ServiceAccount([
                'key' => config('kollus.service_account.key'),
                'api_access_token' => config('kollus.service_account.api_access_token')
            ]);

            $kollusApiClient->setServiceAccount($serviceAccount);
            $kollusApiClient->connect();
            if (config('kollus.use_https')) {
                $kollusApiClient->setSchema('https');
            }

            return $kollusApiClient;
        });

        $this->app->singleton(Client\VideoGatewayClient::class, function () {

            $kollusVideoGatewayClient = new Client\VideoGatewayClient(
                config('kollus.domain'),
                config('kollus.api_version'),
                config('kollus.language')
            );

            $serviceAccount = new Container\ServiceAccount([
                'key' => config('kollus.service_account.key'),
                'custom_key' => config('kollus.service_account.custom_key'),
                'security_key' => config('kollus.service_account.security_key', null),
            ]);
            if (config('kollus.use_https')) {
                $kollusVideoGatewayClient->setSchema('https');
            }

            $kollusVideoGatewayClient->setServiceAccount($serviceAccount);
            $kollusVideoGatewayClient->connect();

            return $kollusVideoGatewayClient;
        });

        $this->app->singleton(Callback::class, function () {

            $serviceAccount = new Container\ServiceAccount([
                'key' => config('kollus.service_account.key'),
                'custom_key' => config('kollus.service_account.custom_key'),
                'security_key' => config('kollus.service_account.security_key'),
            ]);

            $kollusCallback = new Callback($serviceAccount);

            return $kollusCallback;
        });
    }
1086179
protected function registerMigrationService(): void
    {
        $config = $this->app['config'];
        $config->set('database.migrations', $config->get('database.migrations') ?: 'migrations');
        $this->app->register(\Illuminate\Database\MigrationServiceProvider::class);

        $this->app->alias(
            'migration.repository',
            \Illuminate\Database\Migrations\MigrationRepositoryInterface::class
        );

        $this->app->singleton(
            'migrator',
            function ($app) {
                $repository = $app['migration.repository'];

                return new Migrator($repository, $app['db'], $app['files']);
            }
        );

        $this->app->alias(
            'migrator',
            \Illuminate\Database\Migrations\Migrator::class
        );
    }
390304
public function register()
    {   
        $providers = config('app','core_providers');
        foreach ($providers as $key => $value) {
            $this->getContainer()->add($value);
        }
    }
1124230
public function register()
    {
        $this->bindRouteModel();

        $this->loadAdminAuthConfig();

        $this->registerRouteMiddleware();

        $this->registerPolicies();

        $this->commands($this->commands);
    }
757686
public function register()
    {

        $this->mergeConfigFrom(
            __DIR__ . '/config/config.php', 'bluelines'
        );

        $this->app->bind(
            'Blue', function () {
            return new BluelinesApp();
        });

        $this->registerFactoriesPath(__DIR__.'/factories');
    }