Register any package services.
546006
public function register()
    {
        $this->registerConfig();
        $this->registerEventLoop();
        $this->registerConnector();
        $this->registerFactory();
        $this->registerDongleUssd();
        $this->registerAmiListen();
        $this->registerAmiAction();
        $this->registerDongleSms();
        $this->registerAmiCli();
        $this->commands([
            'command.ami.dongle.ussd',
            'command.ami.dongle.sms',
            'command.ami.listen',
            'command.ami.action',
            'command.ami.cli',
        ]);
    }
1093844
public function register()
    {
        $this->loadViewsFrom(__DIR__.'/resources/views/', $this->_packageTag);
        $this->mergeConfigFrom(__DIR__.'/config/exceptions.php', $this->_packageTag);
        $this->publishFiles();
    }
1268927
public function register()
    {
        $this->registerLangFileManager();
        $this->setupRoutes($this->app->router);

        $this->app->singleton('langfile', function ($app) {
            return new LangFiles($app['config']['app']['locale']);
        });

        // use this if your package has a config file
        // config([
        //         'config/langfilemanager.php',
        // ]);
    }
1336988
public function register()
    {
        parent::register();
        $this->mergeConfig();
        $this->registerHelpers();
        $this->bindRepositories();
        $this->bindOtherStuff();

        if (config('app.env') === 'testing') {
            // We're registering all routes here to unify the whole process between Laravel & Orchestra setup
            $this->app->booted(function ($app) {
                $app->make(RoutesService::class)->registerAll();
            });
        }
    }
32516
protected function registerPackages()
    {
        $packages = (array) $this->config->get('packages');

        /** @var PackageResolver $resolver */
        $resolver = $this->container->get('package.resolver');

        $resolver->registerPackages($packages);

        return $this;
    }
1268102
public function register()
    {
        $this->config = $this->app->make('config');
        $this->packages = $this->config->get('domains.user-binding');

        $files = \File::allFiles(config_path('domains'));

        foreach ($files as $file) {
            if ($bindings = $this->config->get('domains.'.basename($file->getFilename(), '.php'))) {
                if (array_has($bindings, 'providers')) {
                    $this->provideService(array_get($bindings, 'providers'));
                }

                if (array_has($bindings, 'repositories')) {
                    $this->provideRepositories(array_get($bindings, 'repositories'));
                }

                if (array_has($bindings, 'eloquent_repositories')) {
                    $this->provideEloquentRepositories(array_get($bindings, 'eloquent_repositories'));
                }
            }
        }

        if ($this->app->runningInConsole()) {
            $this->commands([
                GenerateDomain::class,
            ]);
        }
    }
220800
public function register()
    {

        // Package commands available for laravel or lumen higher than 5.1

        if(version_compare($this->app->version(), '5.1', ">=") or starts_with($this->app->version(), "Lumen")) {

            if ($this->app->runningInConsole()) {

                // Registering commands

                $this->commands([
                    ListIndicesCommand::class,
                    CreateIndexCommand::class,
                    UpdateIndexCommand::class,
                    DropIndexCommand::class,
                    ReindexCommand::class
                ]);

            }
        }

        $this->app->bind('es', function () {
            return new Connection();
        });
    }
168220
private function registerServices()
    {
        $this->app->singleton('pluggables', function ($app) {
            return new Pluggables($app['config'], $app['files']);
        });

        $this->app->booting(function ($app) {
            $app['pluggables']->register();
        });
    }
858100
public function register()
    {
        $this->setupConfig();

        $services = config('microservice.services');
        $currentEnv = app()->environment();

        /** @var array $services */
        foreach ($services as $service) {
            if ($service['enabled'] && $this->isInCurrentEnv($currentEnv, $service['environments'])) {
                if (array_get($service, 'config')) {
                    $this->app->configure($service['config']);
                }

                $this->app->register($service['provider']);
            }
        }

        app()->middleware(ConvertEmptyStringsToNull::class);
    }
695798
protected function registerServices()
    {
        $services = array_filter($this->config->get('app.services'), function ($service) {
            return class_exists($service);
        });

        foreach ($services as $service) {
            /** @var \Fyuze\Kernel\Service $obj */
            $obj = new $service($this->container);
            $obj->services();

            $this->services[] = $obj;
        }
    }
537092
public function register()
    {
        // If script is running CLI we don't activate this plugin
        if ($this->app->runningInConsole())
        {
            return;
        }

        // Default package configuration
        $this->mergeConfig();
        
        // Register singleton
        $this->app->singleton('active', function ($app) {
           return new Active($app['router']->current()->getName());
        });
        
        // Register Facade
        $loader = \Illuminate\Foundation\AliasLoader::getInstance();
        $loader->alias('Active', Facades\Active::class);
    }
1244758
private function registerPackages()
    {
        // Form field generation
        AliasLoader::getInstance()->alias('Former', \Former\Facades\Former::class);
        $this->app->register('Former\FormerServiceProvider');

        // Image resizing
        AliasLoader::getInstance()->alias('Croppa', \Bkwld\Croppa\Facade::class);
        $this->app->register('Bkwld\Croppa\ServiceProvider');

        // PHP utils
        $this->app->register('Bkwld\Library\ServiceProvider');

        // HAML
        $this->app->register('Bkwld\LaravelHaml\ServiceProvider');

        // BrowserDetect
        AliasLoader::getInstance()->alias('Agent', \Jenssegers\Agent\Facades\Agent::class);
        $this->app->register('Jenssegers\Agent\AgentServiceProvider');

        // File uploading
        $this->app->register('Bkwld\Upchuck\ServiceProvider');

        // Creation of slugs
        $this->app->register('Cviebrock\EloquentSluggable\ServiceProvider');

        // Support for cloning models
        $this->app->register('Bkwld\Cloner\ServiceProvider');
    }
836323
public function register()
	{
        $this->app->bind('vextSchema', function() {
            return new VextBuilder(Schema::getConnection());
        });

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

        $this->app->booting(function(){
            $loader = \Illuminate\Foundation\AliasLoader::getInstance();
            $loader->alias('VextSchema', 'Qlcorp\VextFramework\Facades\VextSchema');
            $loader->alias('VextValidate', 'Qlcorp\VextFramework\Facades\VextValidate');
        });

        $this->app->bindShared('command.migrate.generate', function($app) {
            $packagePath = $app['path.base'].'/vendor';
            $repository = $app['migration.repository'];
            $migrator = new VextMigrator($repository, $app['db'], $app['files']);
            return new GenerateModelsCommand($migrator, $packagePath);
        });

        $this->commands('command.migrate.generate');
	}
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();
    }
1097835
protected function registerServices()
    {
        foreach ($this->serviceBindings as $key => $value) {
            is_numeric($key)
                    ? $this->app->singleton($value)
                    : $this->app->singleton($key, $value);
        }
    }
701164
public void register() {
        LOGGER.debug("Register mount tracker as OSGi service");

        synchronized (this) {
            if (serviceRegistration != null) {
                throw new IllegalStateException(String.format("%s [%s] had been already registered.", getClass()
                    .getSimpleName(), this));
            }
            serviceRegistration = bundleContext.registerService(SERVICE_CLASSES, this, properties);
        }
    }
75135
protected function registerPublishes(): void
    {
        $this->publishes([
            $this->packagePath('config') => config_path('/'),
        ], 'config');

        $this->publishes([
            $this->homeDirectory . '/../resources/lang' => base_path('resources/lang/vendor/' . $this->packageName),
        ], 'language');
    }