Create aliases for the Model Bindings.

@see registerModelBindings
347492
protected function registerFacadesAliases()
    {
        $loader = AliasLoader::getInstance();
        $loader->alias('AuzoToolsPermissionRegistrar', AuzoToolsPermissionRegistrarFacade::class);
        $loader->alias('GenerateAbilities', GenerateAbilitiesFacade::class);
    }
171980
protected function registerBindings()
    {
        $this->app->bind('FluxBB\Models\GroupRepositoryInterface', function ($app) {
            return new GroupRepository($app['cache']);
        });

        $this->app->bind('FluxBB\Models\ConfigRepositoryInterface', function ($app) {
            return new ConfigRepository($app['cache.store'], $app['Illuminate\Database\ConnectionInterface']);
        });

        $this->app->bind('FluxBB\Models\CategoryRepositoryInterface', function ($app) {
            return new CategoryRepository($app['Illuminate\Database\ConnectionInterface']);
        });

        $this->app->bind('FluxBB\Models\ConversationRepositoryInterface', function ($app) {
            return new ConversationRepository($app['Illuminate\Database\ConnectionInterface']);
        });
    }
625854
protected function registerAliases()
    {
        foreach ($this->aliases as $abstract => $aliases) {
            foreach ((array) $aliases as $alias) {
                $this->app->alias($alias, $abstract);
            }
        }
    }
951856
public function setupBindingDefinition(BindingDefinition $bindingDefinition) {
		if ($this->allowedNewEiTypeIds !== null) {
			$toManyMappingResult = $bindingDefinition->getMappingResult()->__get($this->propertyName);
			
			foreach ($toManyMappingResult->__get('newMappingForms') as $key => $mfMappingResult) {
				$chosenId = null;
				if ($mfMappingResult->eiuEntryForm->containsPropertyName('chosenId')) {
					$chosenId = $mfMappingResult->eiuEntryForm->chosenId;
				} else {
					$chosenId = $mfMappingResult->eiuEntryForm->getObject()->getChosenId();
				}
				
				if (in_array($chosenId, $this->allowedNewEiTypeIds)) continue;
				
				$mfMappingResult->getBindingErrors()->addErrorCode('chosenId', 'ei_impl_ei_type_disallowed');
			}
		}
	}
261052
protected function registerClassAlias()
    {
        // Model to Repository
        class_alias(
            Repository\Exception\ValidateFailException::class,
            'Windwalker\Core\Model\Exception\ValidateFailException'
        );
        class_alias(Repository\Traits\CliOutputModelTrait::class, 'Windwalker\Core\Model\Traits\CliOutputModelTrait');
        class_alias(Repository\Traits\DatabaseModelTrait::class, 'Windwalker\Core\Model\Traits\DatabaseModelTrait');
        class_alias(
            Repository\Traits\DatabaseRepositoryTrait::class,
            'Windwalker\Core\Model\Traits\DatabaseRepositoryTrait'
        );
        class_alias(Repository\DatabaseRepository::class, 'Windwalker\Core\Model\DatabaseModelRepository');
        class_alias(Repository\DatabaseRepository::class, 'Windwalker\Core\Repository\DatabaseModelRepository');
        class_alias(
            Repository\DatabaseRepositoryInterface::class,
            'Windwalker\Core\Model\DatabaseRepositoryInterface'
        );
        class_alias(Repository\Repository::class, 'Windwalker\Core\Model\ModelRepository');
        class_alias(Repository\Repository::class, 'Windwalker\Core\Repository\ModelRepository');
    }
1153466
protected function registerBaseTenantBindings()
    {
        $this->singleton(TenantContract::class, function ($app) {
            return new Tenant(new NullUser(), new NullTenant(), new NullTenant());
        });

        $this->alias(TenantContract::class, 'auth.tenant');
    }
198716
protected function registerCustomBindings(): void
    {
        $repositoryFactory = $this->app->make(IRepositoryFactory::class);

        foreach (config('laravel_repositories.bindings') as $className => $repository) {
            $repositoryFactory->register($className, $repository);
        }
    }
951174
public function registerBindings()
	{
		// Register the sitemap.xml generator
		$this->app->singleton(
			'vinicius73.seotools.generators.sitemap',
			function ($app) {
				return new SitemapGenerator();
			}
		);

		// Register the sitemap configuration
		$this->app->singleton(
			'vinicius73.seotools.generators.sitemap.run',
			function ($app) {
				$class = $app['config']->get('seotools::sitemap.classrun');

				return new $class($app['vinicius73.seotools.generators.sitemap']);
			}
		);

		// Register the meta tags generator
		$this->app->singleton(
			'vinicius73.seotools.generators.meta',
			function ($app) {
				$defaults = $app['config']->get('seotools::meta.defaults');
				$webmaster = $app['config']->get('seotools::webmaster');

				return new MetaGenerator($defaults, $webmaster);
			}
		);

		// Register the open graph properties generator
		$this->app->singleton(
			'vinicius73.seotools.generators.opengraph',
			function ($app) {
				return new OpenGraphGenerator();
			}
		);

		// Register the open graph properties generator helper
		$this->app->singleton(
			'vinicius73.seotools.generators.opengraph.helper',
			function ($app) {
				$defaults = $app['config']->get('seotools::opengraph.defaults');

				return new OpenGraphHelper(array(), $defaults);
			}
		);
	}
712990
protected function createAliases()
    {
        $loader = \Illuminate\Foundation\AliasLoader::getInstance();
        $loader->alias('BumbleStr', 'Monarkee\Bumble\Support\Facades\BumbleStr');
        $loader->alias('BumbleGravatar', 'Monarkee\Bumble\Support\Facades\Gravatar');

        $loader->alias('BumbleForm', 'Collective\Html\FormFacade');
        $loader->alias('BumbleHtml', 'Collective\Html\HtmlFacade');
    }
995154
protected function registerAliases() : void
    {
        $aliases = [
            'bitcoind'         => 'Denpa\Bitcoin\ClientFactory',
            'bitcoind.client'  => 'Denpa\Bitcoin\LaravelClient',
        ];

        foreach ($aliases as $key => $aliases) {
            foreach ((array) $aliases as $alias) {
                $this->app->alias($key, $alias);
            }
        }
    }
634847
private void initRegisteredBindings() {
        
        Enumeration<URL> bindingsConfiguration;
        try {
            bindingsConfiguration = ClassLoaderUtils.getClassLoader().getResources("META-INF/bindings.xml");
        } catch (IOException e) {
            throw new IllegalStateException("Error registering bindings: " + e.getMessage(), e);
        }

        registerConfigurations(bindingsConfiguration);
    }
1181819
protected function registerBindings()
    {
        /** @noinspection PhpUndefinedMethodInspection */
        $config = $this->app['config']->get('elasticsearch', []);

        $this->app->/** @scrutinizer ignore-call */ singleton(ElasticsearchServiceContract::class, function () use ($config) {
            return new ElasticsearchService(ClientBuilder::fromConfig($config));
        });
    }
1009300
protected function registerFacadesAliases(): void
    {
        $loader = AliasLoader::getInstance();

        foreach ((array) $this->facades as $facade => $aliases) {
            foreach ((array) $aliases as $alias) {
                $loader->alias($alias, $facade);
            }
        }
    }
914909
private function registerBindings()
    {
        $this->app->bind('society.isInstalled', function ($app) {
            return
                file_exists(base_path('.env')) &&
                file_exists(storage_path('app/installed')) &&
                Schema::hasTable('migrations');
        });
    }
754433
private function registerAliases()
    {
        $aliasLoader = AliasLoader::getInstance();
//        $aliasLoader->alias( 'TranslationCache', \Waavi\Translation\Facades\TranslationCache::class );
        $aliasLoader->alias( 'Activation', \Cartalyst\Sentinel\Laravel\Facades\Activation::class );
        $aliasLoader->alias( 'Reminder', \Cartalyst\Sentinel\Laravel\Facades\Reminder::class );
        $aliasLoader->alias( 'Sentinel', \Cartalyst\Sentinel\Laravel\Facades\Sentinel::class );
        $aliasLoader->alias( 'GlideImage', \Roboc\Glide\Support\Facades\GlideImage::class );
        $aliasLoader->alias( 'Excel', \Maatwebsite\Excel\Facades\Excel::class );
    }
144225
public function registerEntityAliases() {

		$factory = Yii::$app->factory->getContainer();

		$factory->set( 'localeService', 'cmsgears\core\common\services\entities\LocaleService' );

		$factory->set( 'countryService', 'cmsgears\core\common\services\entities\CountryService' );
		$factory->set( 'provinceService', 'cmsgears\core\common\services\entities\ProvinceService' );
		$factory->set( 'regionService', 'cmsgears\core\common\services\entities\RegionService' );
		$factory->set( 'cityService', 'cmsgears\core\common\services\entities\CityService' );

		$factory->set( 'siteService', 'cmsgears\core\common\services\entities\SiteService' );
		$factory->set( 'themeService', 'cmsgears\core\common\services\entities\ThemeService' );

		$factory->set( 'templateService', 'cmsgears\core\common\services\entities\TemplateService' );
		$factory->set( 'objectService', 'cmsgears\core\common\services\entities\ObjectDataService' );

		$factory->set( 'permissionService', 'cmsgears\core\common\services\entities\PermissionService' );
		$factory->set( 'roleService', 'cmsgears\core\common\services\entities\RoleService' );

		$factory->set( 'userService', 'cmsgears\core\common\services\entities\UserService' );
	}
538979
protected function registerProviders()
    {
        /** @var Container $container */
        $container = $this->getContainer();

        // Register Aliases
        $aliases = (array) $this->get('di.aliases');

        foreach ($aliases as $alias => $target) {
            $container->alias($alias, $target);
        }

        $container->registerServiceProvider(new SystemProvider($this, $this->config));

        $providers = (array) $this->config->get('providers');

        foreach ($providers as $interface => &$provider) {
            if ($provider === false) {
                continue;
            }

            if (is_subclass_of($provider, ServiceProviderInterface::class)) {
                // Handle provider
                if ($provider instanceof ClassMeta || (is_string($provider) && class_exists($provider))) {
                    $provider = $container->newInstance($provider);
                }

                if ($provider === false) {
                    continue;
                }

                $container->registerServiceProvider($provider);

                if ($provider instanceof BootableProviderInterface
                    || method_exists($provider, 'boot')) {
                    $provider->boot($container);
                }
            } else {
                // Handle Service
                if (is_numeric($interface)) {
                    $container->prepareSharedObject($provider);
                } else {
                    $container->bindShared($interface, $provider);
                }
            }
        }

        foreach ($providers as $provider) {
            if ($provider === false) {
                continue;
            }

            if (is_subclass_of($provider, ServiceProviderInterface::class)
                && (
                    $provider instanceof BootableDeferredProviderInterface
                    || method_exists($provider, 'bootDeferred')
                )) {
                $provider->bootDeferred($container);
            }
        }
    }