Register the credentials class.

@return void
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);
    }
374483
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('tymon.jwt.secret');
    }
485945
public function register()
    {
        $this->app->bind('Setting', Setting::class);
        $this->app->bind(SettingStorageContract::class, EloquentStorage::class);
    }
888403
public function register() {
        $this->registerAuthFactory($this->app);
        $this->registerBitbucketFactory($this->app);
        $this->registerManager($this->app);
        $this->registerBindings($this->app);
    }
450956
public function register()
    {
        $this->getPermissions()->each(function (Permission $permission) {
            $ability = $permission->slug;
            $policy  = function ($user) use ($permission) {
                return $user->hasRole($permission->roles);
            };

            if (Str::contains($permission->slug, '@')) {
                $policy  = $permission->slug;
                $ability = $permission->name;
            }

            $this->gate->define($ability, $policy);
        });
    }
1126739
public function register()
    {
        $errorLevel = $this->config('errorLevel');
        set_error_handler([$this, 'handleError'], $errorLevel);
        set_exception_handler([$this, 'handle']);
        register_shutdown_function(function () {
            if (PHP_SAPI === 'cli') {
                return;
            }
            $error = error_get_last();
            if (!is_array($error)) {
                return;
            }
            $fatals = [
                E_USER_ERROR,
                E_ERROR,
                E_PARSE,
            ];
            if (!in_array($error['type'], $fatals, true)) {
                return;
            }
            $this->handleFatalError(
                $error['type'],
                $error['message'],
                $error['file'],
                $error['line']
            );
        });
    }
103854
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/../../config/verification.php', 'verification');

        $this->app->singleton('auth.verification', function ($app) {
            return new VerificationBrokerManager($app);
        });

        $this->app->bind('auth.verification.broker', function ($app) {
            return $app->make('auth.verification')->broker();
        });

        foreach ($this->aliases as $key => $aliases) {
            foreach ($aliases as $alias) {
                $this->app->alias($key, $alias);
            }
        }

        $this->registerCommands();
    }
464253
public function register()
    {
        $this->registerRepository();
        $this->registerMigrator();
        $this->registerTranslation();
        // for create migration
        $this->registerCreator();
        // for create migration

        // add commands
        $this->registerCommands();


    }
785703
public function register()
    {
        $packages = $this->repository->enabled();

        $packages->each(function($properties)
        {
            $this->registerServiceProvider($properties);
        });
    }
349738
public function register()
    {
        $this->registerInstallCommand();
        $this->registerAuthSettingsInstallCommand();
        $this->registerAuthFilesInstallCommand();
        $this->registerAuthModelInstallCommand();
        $this->registerAuthViewsInstallCommand();
        //$this->registerInstallMiddlewareCommand();
    }
23715
public function register()
    {
        $this->app['events']->listen(JobProcessing::class, function () {
            $connection = $this->app['config']->get('queue.failed.connection', null);
            $tableName  = $this->app['config']->get('queue.failed.table', 'failed_jobs');

            $schema = $this->app['registry']
                ->getConnection($connection)
                ->getSchemaManager();

            if (!$schema->tablesExist($tableName)) {
                $schema->createTable(
                    (new FailedJobTable($tableName))->build()
                );
            }
        });
    }
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;
        });
    }
519870
public function register()
    {
        parent::register();

        $this->registerConfig();

        $this->singleton(Contracts\Gravatar::class, function($app) {
            /** @var  \Illuminate\Contracts\Config\Repository  $config */
            $config = $app['config'];

            return new Gravatar(
                $config->get('gravatar.default', 'mm'),
                $config->get('gravatar.size', 80),
                $config->get('gravatar.max-rating', 'g')
            );
        });
    }
683744
public function register()
	{
	    $this->app->singleton('geocode',function($app)
	    {
	        return new \Jcf\Geocode\Geocode;
	    });

	    if ($this->app instanceof LaravelApplication) {
	        $this->app->booting(function ()
	        {
		    $loader = \Illuminate\Foundation\AliasLoader::getInstance();
		    $loader->alias('Geocode', 'Jcf\Geocode\Facades\Geocode');
	        });
	    }
	}
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'
        ]);
    }
470973
public function register()
    {
        // Add database driver.
        $this->app->resolving('db', function ($db) {
            /** @var DatabaseManager $db */
            $db->extend('pdo_access', function ($config, $name) {
                $config['name'] = $name;
                return new AccessConnection($config);
            });
        });
    }
200424
public function register()
    {
        $this->mergeConfigFrom(
            __DIR__.'/../config/keycdn.php', 'keycdn'
        );

        $this->app->bind(KeyCDN::class, function() {
            return KeyCDN::create(config('keycdn.key'));
        });

        $this->app->alias(KeyCDN::class, 'keycdn');
    }