Register the service provider.
971341
public function register()
    {
        $this->mergeConfigFrom(__DIR__.'/../config/config.php', 'imageupload');

        $this->app->singleton('imageupload', function ($app) {
            return new Imageupload(new ImageManager());
        });
    }
663366
public function register() {

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

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

        $this->configureViews();

        $this->configurePaths();

        $this->registerServices();

        $this->registerRoutes();

        $this->registerTasks();

        $this->registerEventListeners();

        $this->registerConsoleCommands();
    }
939814
public function register()
    {
        parent::register();

        $this->registerConfig();
        $this->registerProviders([
            Providers\RoutingServiceProvider::class,
            Providers\UtilitiesServiceProvider::class,
        ]);
        $this->registerLocalization();
    }
618084
public function register()
    {
        parent::register();

        $this->registerConfig();
        $this->registerArcanesoftDatabase();
        $this->registerProviders([
            Providers\AuthorizationServiceProvider::class,
            Providers\RouteServiceProvider::class,
            Providers\PackagesServiceProvider::class,
        ]);
    }
188110
public function register()
    {

        if ('LaravelCommode\Common\CommodeCommonServiceProvider' !== get_class($this)) {
            /**
             * Prepare service
             */
            $this->prepareService();

            /**
             * Bind app's 'booting' event resolving, aliases and launching methods
             */
            $this->app->booting($this->getResolver()->makeClosure(function () {

                if (count($this->aliases) > 0) {
                    $loader = AliasLoader::getInstance();

                    foreach ($this->aliases as $facadeName => $facadeClass) {
                        $loader->alias($facadeName, $facadeClass);
                    }
                }

                $this->launchClosure();
            }));

        }

        /**
         * Register service
         */
        $this->registering();
    }
849393
public function register()
    {
        $this->resolveDirectories();

        $this->tryRequireHelpers(self::ON_REGISTER);
        $this->tryRegisterProviders(self::ON_REGISTER);

        if (method_exists($this, $this->bootingMethod)) {
            $this->app->booting(function (Application $app) {
                $app->call([$this, $this->bootingMethod]);
            });
        }

        if (method_exists($this, $this->bootedMethod)) {
            $this->app->booted(function (Application $app) {
                $app->call([$this, $this->bootedMethod]);
            });
        }

        // Config
        $this->registerConfigFiles();

        // Middlewares
        if (!$this->app->runningInConsole()) {
            $router = $this->app->make('router');
            $kernel = $this->app->make('Illuminate\Contracts\Http\Kernel');

            foreach ($this->prependMiddleware as $middleware) {
                $kernel->prependMiddleware($middleware);
            }

            foreach ($this->middleware as $middleware) {
                $kernel->pushMiddleware($middleware);
            }

            foreach ($this->routeMiddleware as $key => $middleware) {
                $router->middleware($key, $middleware);
            }
        }

        // Container bindings and aliases
        foreach ($this->bindings as $binding => $class) {
            $this->app->bind($binding, $class);
        }

        foreach ($this->weaklings as $binding => $class) {
            $this->bindIf($binding, $class);
        }

        foreach (['share' => $this->share, 'shared' => $this->shared] as $type => $bindings) {
            foreach ($bindings as $binding => $class) {
                $this->share($binding, $class, [], $type === 'shared');
            }
        }

        foreach ($this->singletons as $binding => $class) {
            if ($this->strict && !class_exists($class) && !interface_exists($class)) {
                throw new \Exception(get_called_class().": Could not find alias class [{$class}]. This exception is only thrown when \$strict checking is enabled");
            }
            $this->app->singleton($binding, $class);
        }

        foreach ($this->aliases as $alias => $full) {
            if ($this->strict && !class_exists($full) && !interface_exists($full)) {
                throw new \Exception(get_called_class().": Could not find alias class [{$full}]. This exception is only thrown when \$strict checking is enabled");
            }
            $this->app->alias($alias, $full);
        }

        // Commands
        if ($this->app->runningInConsole()) {
            foreach ($this->findCommands as $path) {
                $dir = path_get_directory((new ReflectionClass(get_called_class()))->getFileName());
                $classes = $this->findCommandsIn(path_join($dir, $path), $this->findCommandsRecursive);

                $this->commands = array_merge($this->commands, $classes);
            }
            if (is_array($this->commands) && count($this->commands) > 0) {
                $commands = [];
                foreach ($this->commands as $k => $v) {
                    if (is_string($k)) {
                        $this->app[ $this->commandPrefix.$k ] = $this->app->share(function ($app) use ($k, $v) {
                            return $app->build($v);
                        });

                        $commands[] = $this->commandPrefix.$k;
                    } else {
                        $commands[] = $v;
                    }
                }
                $this->commands($commands);
            }
        }
        // Facades
        if (class_exists('Illuminate\Foundation\AliasLoader')) {
            \Illuminate\Foundation\AliasLoader::getInstance($this->facades)->register();
        }

        // Helpers
        $this->tryRequireHelpers(self::ON_REGISTERED);

        $this->tryRegisterProviders(self::ON_REGISTERED);

        return $this->app;
    }
968463
public function register()
    {
        $this->registerAdapterFactory();
        $this->registerCacheFactory();
        $this->registerFlysystemFactory();
        $this->registerManager();
        $this->registerBindings();
    }
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


        });
    }
176140
public function register() {
        $this->loadConfiguration();

        /** Register language repository . */
        $this->app->bind('lang-db-repo', function() {
            return new LanguageRepository(
                new Language()
            );
        });

        /** Register translations repository . */
        $this->app->bind('translations-db-repo', function() {
            return new TranslationsRepository(
                new Translation()
            );
        });

        /** Register driver manager */
        $this->app->bind('driver-translator-manager', function() {
            return (new Manager(
                config('laravel-translator')
            ));
        });

        /** Register translator . */
        $this->app->singleton('laravel-translator', function($app) {
            return new Translator(
                config('laravel-translator'),
                $app['driver-translator-manager']
            );
        });
    }
1134755
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/config.php', 'slack-output');

        $this->app->singleton(Service::class, function () {
            return new Service(config('slack-output'));
        });
    }
464253
public function register()
    {
        $this->registerRepository();
        $this->registerMigrator();
        $this->registerTranslation();
        // for create migration
        $this->registerCreator();
        // for create migration

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


    }
621618
public function register()
    {
        $this->registerRevisionRepository();
        $this->registerUserRepository();
        $this->registerGroupRepository();
        $this->registerCredentials();

        $this->registerLoginController();
        $this->registerRegistrationController();
        $this->registerResetController();
        $this->registerActivationController();
    }
147672
public function register()
    {
        $this->mergeConfigFrom(
            $this->getBasePath() . '/config/admin.php',
            'admin'
        );

        $this->registerMiddleware();
        $this->registerFactory();
        $this->app->instance('admin.instance', new Admin($this->app));
        $this->app->bind(RepositoryInterface::class, Repository::class);
    }
481880
public function register()
    {
        $this->registerRouter();

        $this->registerUrlGenerator();

        $this->registerRedirector();

        $this->registerResponseFactory();

        $this->registerControllerDispatcher();
    }
477085
public function register()
    {
        Framework::registerPackage('framework');

        // Register 3rd party providers
        $this->app->register(WidgetServiceProvider::class);

        $this->app->register(HelloquentServiceProvider::class);
        $this->app->register(ViewServiceProvider::class);
        $this->app->register(HttpServiceProvider::class);
        $this->app->register(StatisticsServiceProvider::class);
        $this->app->register(DynatableServiceProvider::class);
    }
639039
public function register()
    {
        $this->registerLockdownConfiguration();
        $this->registerLockdownFacade();
        $this->registerUserProvider();
        $this->registerRoleProvider();
        $this->registerPermissionProvider();
        $this->registerLockdown();
        $this->registerLockdownGuard();
        $this->registerCommands();
    }