Register facade

@return void
973832
public function register()
    {
        static $registered = false;
        // Check if facades are activated
        if (Facade::getFacadeApplication() == $this->app && !$registered) {
            class_alias(\DreamFactory\Core\GraphQL\Facades\GraphQL::class, 'GraphQL');
            $registered = true;
        }

        parent::register();
    }
419968
public function register()
    {
        $this->mergeConfigFrom(__DIR__.'/../config/tracy.php', 'tracy');

        $config = Arr::get($this->app['config'], 'tracy');

        if (Arr::get($config, 'panels.terminal') === true) {
            $this->app->register(TerminalServiceProvider::class);
        }

        $this->app->singleton(BlueScreen::class, function () {
            return Debugger::getBlueScreen();
        });

        $this->app->singleton(Bar::class, function ($app) use ($config) {
            return (new BarManager(Debugger::getBar(), $app['request'], $app))
                ->loadPanels(Arr::get($config, 'panels', []))
                ->getBar();
        });

        $this->app->singleton(DebuggerManager::class, function ($app) use ($config) {
            return (new DebuggerManager(
                DebuggerManager::init($config),
                $app[Bar::class],
                $app[BlueScreen::class],
                new Session
            ))->setUrlGenerator($app['url']);
        });
    }
561546
public function register()
    {
        $this->registerConfigurationMapper();
        $this->registerCacheManager();
        $this->registerEntityManager();
        $this->registerClassMetadataFactory();
        $this->registerValidationVerifier();

        $this->commands([
            'Mitch\LaravelDoctrine\Console\GenerateProxiesCommand',
            'Mitch\LaravelDoctrine\Console\SchemaCreateCommand',
            'Mitch\LaravelDoctrine\Console\SchemaUpdateCommand',
            'Mitch\LaravelDoctrine\Console\SchemaDropCommand'
        ]);
    }
235588
public function register()
    {
        if (! function_exists('add_theme_support') || empty($this->features)) {
            return;
        }

        foreach ($this->features as $feature => $value) {
            add_theme_support($feature, $value);
        }
    }
285580
public function register()
	{
		$this->app['authClient'] = $this->app->share(function($app)
                {
                    return new AuthClient;
                });
                
                $this->app['userClient'] = $this->app->share(function($app)
                {
                    return new UserClient;
                });

                $this->app['client'] = $this->app->share(function($app)
                {
                    return new Client;
                });
                
                $this->app['solariumClient'] = $this->app->share(function($app)
                {
                    return new SolariumClientImpl();
                });
                
                // Shortcut so developers don't need to add an Alias in app/config/app.php
                $this->app->booting(function()
                {
                    $loader = \Illuminate\Foundation\AliasLoader::getInstance();
                    $loader->alias('AuthClient', 'Ademes\Core\Facades\AuthClient');
                    $loader->alias('UserClient', 'Ademes\Core\Facades\UserClient');
                    $loader->alias('HttpClient', 'Ademes\Core\Facades\HttpClient');
                    $loader->alias('SolariumClient', 'Ademes\Core\Facades\SolariumClient');
                });
	}
974435
public function register()
    {
        $this->app['events']->listen('doctrine.extensions.booting', function () {
            $registry = $this->app->make('registry');

            foreach ($registry->getManagers() as $manager) {
                $chain = $manager->getConfiguration()->getMetadataDriverImpl();

                if ($this->hasAnnotationReader($chain)) {
                    $this->registerGedmoForAnnotations($chain);
                }

                if ($this->hasFluentDriver($chain)) {
                    $this->registerGedmoForFluent($chain);
                }
            }
        });
    }
375965
public function register() {
        $this->larapackage('larakit/laravel-larakit', 'larakit', 'public');
        $this->app->bind('larakit:env',
            function ($app) {
                return new \Larakit\Command\Env();
            });
        $this->app->bind('larakit:readiness',
            function ($app) {
                return new \Larakit\Command\Readiness();
            });
        $this->app->bind('larakit:app-provider',
            function ($app) {
                return new \Larakit\Command\AppProvider();
            });
        $this->app->bind('larakit:app-alias',
            function ($app) {
                return new \Larakit\Command\AppAlias();
            });
        $this->app->bind('larakit:app-db',
            function ($app) {
                return new \Larakit\Command\AppDb();
            });
        $this->app->bind('larakit:app-migrate',
            function ($app) {
                return new \Larakit\Command\AppMigrate();
            });
        $this->commands([
            'larakit:env',
            'larakit:app-provider',
            'larakit:app-alias',
            'larakit:app-db',
            'larakit:readiness',
            'larakit:app-migrate',
        ]);
    }
485888
public function register()
    {
        $this->app->singleton('Essentials', function ($app) {
            return new Essentials($app);
        });

        $this->app->alias('Essentials', Facade::class);
    }
914230
public function register()
    {
        // Register the HtmlServiceProvider
        App::register('Illuminate\Html\HtmlServiceProvider');

        // Add aliases to Form/Html Facade
        $loader = AliasLoader::getInstance();
        $loader->alias('Form', 'Illuminate\Html\FormFacade');
        $loader->alias('HTML', 'Illuminate\Html\HtmlFacade');

        // Register the acl:fill-permissions command
        $this->app['acl:fill-permissions'] = $this->app->share(function($app) {
            return new AclFill();
        });
        $this->commands('acl:fill-permissions');
    }
749671
public function register()
    {
        $this->app->register('Collective\Html\HtmlServiceProvider');
        $this->app->register('Zofe\Burp\BurpServiceProvider');
        
        Rapyd::setContainer($this->app);
   
        $this->app->booting(function () {
            $loader  =  \Illuminate\Foundation\AliasLoader::getInstance();

            $loader->alias('Input', 'Illuminate\Support\Facades\Input');
            
            $loader->alias('Rapyd'     , 'Zofe\Rapyd\Facades\Rapyd'     );
            
            //deprecated .. and more facade are really needed ?
            $loader->alias('DataSet'   , 'Zofe\Rapyd\Facades\DataSet'   );
            $loader->alias('DataGrid'  , 'Zofe\Rapyd\Facades\DataGrid'  );
            $loader->alias('DataForm'  , 'Zofe\Rapyd\Facades\DataForm'  );
            $loader->alias('DataEdit'  , 'Zofe\Rapyd\Facades\DataEdit'  );
            $loader->alias('DataFilter', 'Zofe\Rapyd\Facades\DataFilter');
            $loader->alias('DataEmbed' , 'Zofe\Rapyd\Facades\DataEmbed');
            $loader->alias('DataTree' , 'Zofe\Rapyd\Facades\DataTree');
            $loader->alias('Documenter', 'Zofe\Rapyd\Facades\Documenter');


        });
    }
145158
public function register()
	{
        $this->app->singleton('basement', function()
        {
            // retrieve settings from app/config/database.php
            extract(Config::get('database.couchbase'));

            $defaults = array(
                'name' => 'default',
                'host' => isset($host) ? $host : '127.0.0.1',
                'bucket' => isset($bucket) ? $bucket : 'default',
                'password' => isset($password) ? $password : null,
                'user' => null,
                'persist' => isset($persist_conn) ? $persist_conn : false,
                'connect' => true,
                'transcoder' => 'json',
				'environment' => preg_match('/dev|local/i', App::environment()) ? 'development' : App::environment()
            );

            return new Client($defaults);
        });

        // Shortcut so developers don't need to add an Alias in app/config/app.php
        $this->app->booting(function()
        {
            $loader = AliasLoader::getInstance();
            $loader->alias('Cb', 'Shift31\LaravelBasement\Facades\Cb');
        });
	}
1120539
public function register()
    {
        $this->loadAdminAuthConfig();

        $this->registerRouteMiddleware();

        $this->commands($this->commands);

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

        $this->app->singleton(TerminalApplication::class, function ($app) {
            $config = $app['config']['terminal'];
            $artisan = new TerminalApplication($app, $app['events'], $app->version());
            $artisan->resolveCommands($config['commands']);

            return $artisan;
        });

        $this->app->singleton(Kernel::class, function ($app) {
            $config = $app['config']['terminal'];

            return new Kernel($app[TerminalApplication::class], array_merge($config, [
                'basePath' => base_path(),
                //'basePath' => cookie('cd_base_path'),
                'environment' => $app->environment(),
                'version' => $app->version(),
                'endpoint' => $app['url']->route('terminal.endpoint'),
            ]));
        });
    }
920608
public function register() : void
    {
        if ($this->getConfigParam('env') == 'prod') {
            ini_set('display_errors', 'Off');
        } else {
            ini_set('display_errors', 'On');
        }
        error_reporting(E_ALL);
        set_error_handler([$this, 'handleError']);
        set_exception_handler([$this, 'handleException']);
    }
1213680
public function register()
    {
        // Bind the Class
        $this->app->bind('helper', function () {
            return $this->app->make(Helper::class);
        });

        // Register an Alias of the Facade
        $this->app->booting(function () {
            $loader = AliasLoader::getInstance();
            $loader->alias('Helper', HelperFacade::class);
        });
    }
835486
public function register()
    {
        $this->registerBindings();
        $this->app['events']->listen(BuildingSidebar::class, RegisterThemeSidebar::class);

        $this->app['events']->listen(LoadingBackendTranslations::class, function (LoadingBackendTranslations $event) {
            // append translations
        });
    }
324364
public function register()
    {
        // Merge Configuration
        $this->mergeConfigFrom(__DIR__ . '/../config/membership.php', 'membership');

        // Register the Facade
        $this->app->bind('membership', function ($app) {
            return $app->make(Membership::class);
        });
        $this->app->booting(function () {
            $loader = AliasLoader::getInstance();
            $loader->alias('Membership', MembershipFacade::class);
        });
    }
869006
public function register()
    {
        // Bind and tag our Auth components.
        $this->app->bind(IlluminateHasher::class, TrinityCoreHasher::class);
        $this->app->tag(IlluminateHasher::class, 'TrinityCore');

        $this->app->bind(IlluminateGuard::class, TrinityCoreGuard::class);
        $this->app->tag(IlluminateGuard::class, 'TrinityCore');

        // $this->app->bind(IlluminateGuard::class, TrinityCoreGuard::class);
        $this->app->bind('trinitycore', function(){
            return new TrinityCore();
        });
    }