Register Storage\S3 with the contaioner.

@return void
557958
protected function registerS3Storage()
	{
		$this->app->bind('s3', function($app, $params)
        {
            $s3ClientManager = $app->make('S3ClientManager');

            return new Storage\S3($params['attachment'], $s3ClientManager);
        });
	}
363418
public function register()
    {
        if (! $this->config->shouldIntegrateHorizon) {
            return;
        }

        $this->config->loadHorizonConfiguration();

        $this->registerServices();

        if ($this->shouldRebindHorizonRedisFactory()) {
            $this->rebindHorizonRedisFactory();
        }
    }
1233437
public function register()
    {
        // Define package base path
        if (!defined('MEDIA_MANAGER_BASE_PATH')) {
            define('MEDIA_MANAGER_BASE_PATH', realpath(__DIR__.'/../../'));
        }

        // Publishes config file
        $this->publishes([
            MEDIA_MANAGER_BASE_PATH.'/src/Config/media-manager.php' => config_path('media-manager.php'),
        ], 'media-manager');

        $this->mergeConfigFrom(
            MEDIA_MANAGER_BASE_PATH.'/src/Config/media-manager.php', 'media-manager'
        );
    }
623047
private function registerBase()
    {
        $this['request'] = function () {
            return Request::createFromGlobals();
        };

        if ($cache = $this->getConfig()['cache'] ?? null AND $cache instanceof Cache) {
            $this['cache'] = $this->getConfig()['cache'];
        } else {
            $this['cache'] = function () {
                return new FilesystemCache(sys_get_temp_dir());
            };
        }
    }
842388
public function register()
    {
        $this->registerSessionStore();
        $this->registerTranslator();
        $this->registerFlasher();
        $this->registerFlash();
        $this->registerFlashAlias();
    }
1150128
protected function registerResources()
    {
        $userConfigFile = $this->app->configPath().'/stream-laravel.php';
        $packageConfigFile = __DIR__.'/../../config/config.php';
        $config = $this->app['files']->getRequire($packageConfigFile);

        if (file_exists($userConfigFile)) {
            $userConfig = $this->app['files']->getRequire($userConfigFile);
            $config = array_replace_recursive($config, $userConfig);
        }

        $namespace = 'stream-laravel::';

        foreach($config as $key => $value) {
            $this->app['config']->set($namespace . $key , $value);
        }
    }
470140
public function register() {
        $this->registerFilesystemProvider();
        $this->registerDatabaseProvider();
        $this->registerCompressorProvider();
        $this->registerShellProcessor();
        $this->registerArtisanCommands();
    }
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();
    }
490412
protected static function register()
    {
        if (!self::$registered) {
            // set up __autoload
            $autoload = spl_autoload_functions();
            spl_autoload_register(__CLASS__.'::load');
            if (function_exists('__autoload') && ($autoload === false)) {
                // __autoload() was being used, but now would be ignored, add
                // it to the autoload stack
                spl_autoload_register('__autoload');
            }
        }
        self::$registered = true;
    }
1114631
protected function registerContainerBase()
    {
        // Composer
        $this->singleton('composer', function ($app) {
            return new Composer($app->make('files'), $this->basePath());
        });

        // Config
        $this->singleton('config', function () {
            return new ConfigRepository();
        });

        // Files e Storage
        $this->loadComponent('filesystems', '\Bugotech\Foundation\IO\FilesystemServiceProvider', 'filesystem');

        // Log
        $this->singleton('log', function () {
            return new Logger('netforce', [$this->getMonologHandler()]);
        });

        // Artisan - Console
        $this->register('\Bugotech\Foundation\Console\ConsoleServiceProvider');

        // Cache
        $this->singleton('cache', function () {
            return $this->loadComponent('cache', 'Illuminate\Cache\CacheServiceProvider');
        });
        $this->singleton('cache.store', function () {
            return $this->loadComponent('cache', 'Illuminate\Cache\CacheServiceProvider', 'cache.store');
        });

        // Hash
        $this->register('\Illuminate\Hashing\HashServiceProvider');

        // Encryption
        $this->register('\Illuminate\Encryption\EncryptionServiceProvider');
    }
9101
public function register() {
        $configPath = __DIR__ . '/../config/backup-manager.php';
        $this->mergeConfigFrom($configPath, 'backup-manager');
        $this->registerFilesystemProvider();
        $this->registerDatabaseProvider();
        $this->registerCompressorProvider();
        $this->registerShellProcessor();
        $this->registerArtisanCommands();
    }
1341554
protected function registerFlysystem()
    {
        $this->registerManager();

        $this->app->singleton('filesystem.disk', function () {
            return $this->app['filesystem']->disk($this->getDefaultDriver());
        });

        $this->app->singleton('filesystem.cloud', function () {
            return $this->app['filesystem']->disk($this->getCloudDriver());
        });
    }
1284277
public function register()
    {
    	// set the main config file
	    $this->mergeConfigFrom(
		    __DIR__ . '/Config/LFM.php', 'laravel_file_manager'
	    );

		// bind the LFMC Facade
	    $this->app->bind('LFMC', function () {
		    return new LFMC;
	    });
        $this->app->bind('FileManager', function () {
            return new Media;
        });
    }
390304
public function register()
    {   
        $providers = config('app','core_providers');
        foreach ($providers as $key => $value) {
            $this->getContainer()->add($value);
        }
    }
1203072
public static function registerStorage( $storage )
    {
        $object = new $storage();
        if(!($object instanceof StorageInterface)) {
            return false;
        }
        array_push(self::$storageDrivers, $storage);
        return true;
    }
61790
public function register()
    {
        $this->container->bind('config', new Repository(
            new FileLoader(
                new Filesystem,
                $this->container->appPath().'/config'
            ),
            new Resolver,
            $this->container->os()
        ));
    }
862284
protected function registerBackup()
    {
        $this->app->singleton('backup', function (Container $app) {
            $config = $app['config'];
            $registry = $app['backup.registry'];
            $executor = $app['backup.executor'];

            return new Backup($config, $registry, $executor);
        });

        $this->app->alias('backup', Backup::class);
    }