@adimm/x-injection 1.2.0 → 2.0.3

package/dist/index.d.cts

@@ -1,8 +1,5 @@
-import { BindingActivation, BindingDeactivation, BindingConstraints, Container, BindToFluentSyntax, GetOptions, IsBoundOptions, BindingScope, injectFromBase, MetadataName, MetadataTag, ServiceIdentifier } from 'inversify';
-import { Class, RequireAtLeastOne, Except } from 'type-fest';
-
-/** The identifier of the `GlobalAppModule`. */
-declare const GLOBAL_APP_MODULE_ID = "GlobalAppModule";
+import { BindingConstraints, Container, BindInWhenOnFluentSyntax, BindWhenOnFluentSyntax, injectFromBase, MetadataName, MetadataTag, BindingScope } from 'inversify';
+import { Class, RequireAtLeastOne } from 'type-fest';
 
 declare enum InjectionScope {
     /** When the service is resolved, the same cached resolved value will be used. */
@@ -13,810 +10,700 @@ declare enum InjectionScope {
     Request = 2
 }
 
-/** See {@link https://inversify.io/docs/api/decorator/#injectable} for more details. */
-declare function Injectable(scope?: InjectionScope): ClassDecorator;
-
-interface OnEvent<T> {
-    /**
-     * Sets a binding activation handler. The activation handler is invoked after a dependency has been resolved
-     * and before it is added to a scope cache. The activation handler will not be
-     * invoked if the dependency is taken from a scope cache.
-     */
-    activation?: BindingActivation<T>;
+declare enum MiddlewareType {
     /**
-     * Sets a binding deactivation handler on a singleton scope binding.
-     * The deactivation handler is called when the binding is unbound from a container.
-     */
-    deactivation?: BindingDeactivation<T>;
-}
-
-type ProviderToken<T = any> = ProviderIdentifier<T> | DependencyProvider<T>;
-type DependencyProvider<T = any> = Class<T> | Function | ProviderClassToken<T> | ProviderValueToken<T> | ProviderFactoryToken<T>;
-type ProviderClassToken<T> = (ProviderOptions<T> & ProviderScopeOption) & {
-    /** The `class` to be injected. */
-    useClass: Class<T>;
-};
-type ProviderValueToken<T> = ProviderOptions<T> & {
-    /** The _(constant)_ `value` to be injected. */
-    useValue: T;
-};
-type ProviderFactoryToken<T> = (ProviderOptions<T> & ProviderScopeOption) & {
-    /**
-     * Factory `function` that returns an instance of the provider to be injected.
+     * Can be used to register a `middleware` which will be invoked right before importing a `module` into _this_ module.
      *
-     * @example
-     * ```ts
-     * const connectionProvider = {
-     *   provide: 'CONNECTION',
-     *   useFactory: (optionsService: OptionsService, secondService: SecondService) => {
-     *     const options = optionsService.get();
+     * The provided middleware `callback` can either return a `boolean` or a `ProviderModule` instance.
      *
-     *     return new DatabaseConnection(options);
-     *   },
-     *   // `inject` is optional.
-     *   inject: [OptionsService, SecondService]
-     * };
-     * ```
+     * **Note:** _Returning `true` can be used to pass through the middleware without modifying_
+     * _the `ProviderModule` instance, while returning `false` will reject the request of importing that specific module._
      */
-    useFactory: (...providers: any[]) => T;
+    BeforeAddImport = 0,
     /**
-     * Optional list of providers to be injected into the context of the Factory `function`.
+     * Can be used to register a `middleware` which will be invoked right before adding a provider to _this_ module.
      *
-     * See {@link https://inversify.io/docs/api/binding-syntax/#toresolvedvalue} for more details.
-     */
-    inject?: ProviderToken[];
-};
-type ProviderIdentifier<T = any> = Class<T> | Function | symbol | string;
-interface ProviderOptions<T> {
-    /** The injection `token`.  */
-    provide: ProviderIdentifier<T>;
-    /**
-     * Can be used to set a binding handler.
+     * The provided middleware `callback` can either return a `boolean` or a `ProviderToken` object type.
      *
-     * See {@link https://inversify.io/docs/fundamentals/lifecycle/activation/ | Activation}
-     * and {@link https://inversify.io/docs/fundamentals/lifecycle/deactivation/ | Deactivation} lifecycle.
+     * **Note:** _Returning `true` can be used to pass through the middleware without modifying_
+     * _the `ProviderToken` object, while returning `false` will reject the request of adding that specific provider._
      */
-    onEvent?: OnEvent<T>;
+    BeforeAddProvider = 1,
     /**
-     * Specifies whether the binding is used to provide a resolved value for the given {@link ProviderToken | provider}.
+     * Can be used to register a `middleware` which will be invoked right before a provider is returned to the consumer from _this_ module container.
      *
-     * See {@link https://inversify.io/docs/api/binding-syntax/#bindwhenfluentsyntax} for more details.
+     * The provided middleware `callback` can return `anything`.
      */
-    when?: (metadata: BindingConstraints) => boolean;
-}
-interface ProviderScopeOption {
+    BeforeGet = 2,
     /**
-     * The scope determines the caching strategy used to decide whether the service should be resolved or a cached value should be provided.
+     * Can be used to register a `middleware` which will be invoked right before removing an imported module from _this_ module.
      *
-     * If not provided, it'll default to the `ProviderModule` default scope.
-     *
-     * See {@link https://inversify.io/docs/fundamentals/binding/#scope} for more details..
+     * **Note:** _The provided middleware `callback` must return a `boolean` where `true` means that_
+     * _the imported module can be removed and `false` means to keep it._
      */
-    scope?: InjectionScope;
-}
-
-/**
- * The low-level App Container.
- *
- * **Internally used, please use the `AppModule` to interact with it.**
- */
-declare const GlobalContainer: Container;
-
-/**
- * Modules are highly recommended as an effective way to organize your components.
- * For most applications, you'll likely have multiple modules, each encapsulating a closely related set of capabilities.
- *
- * _See {@link ProviderModuleOptions | ProviderModuleOptions}_.
- *
- * **Note:** _Check also the {@link IProviderModuleDefinition}._
- *
- * @example
- * ```ts
- * const EngineModule = new ProviderModule({
- *   identifier: Symbol('EngineModule'),
- *   providers: [EngineService],
- *   exports: [EngineService]
- * });
- *
- * const DashboardModule = new ProviderModule({
- *   identifier: Symbol('DashboardModule'),
- *   providers: [DashboardService],
- *   exports: [DashboardService]
- * });
- *
- * const CarModule = new ProviderModule({
- *   identifier: Symbol('CarModule'),
- *   imports: [EngineModule, DashboardModule],
- *   providers: [CarService],
- *   exports: [CarService]
- * });
- *
- * // Run-time class replacement:
- * const RedCarModule = new ProviderModule({
- *   identifier: Symbol('RedCarModule'),
- *   imports: [CarModule],
- *   providers: [
- *     {
- *       provide: CarService,
- *       useClass: RedCarService,
- *     }
- *   ],
- * });
- *
- * // Run-time factory example:
- * const BlackCarModule = new ProviderModule({
- *   identifier: Symbol('BlackCarModule'),
- *   imports: [CarModule],
- *   providers: [
- *     {
- *       provide: CarService,
- *       useFactory: (carService: CarService) => {
- *         carService.setColor('black');
- *
- *         return carService;
- *       },
- *       inject: [CarService]
- *     }
- *   ],
- * });
- * ```
- */
-declare class ProviderModule implements IProviderModule {
-    isDisposed: boolean;
-    readonly identifier: ModuleIdentifier;
-    isGlobal: boolean;
-    protected isAppModule: IProviderModuleNaked['isAppModule'];
-    protected instantiatedFromDefinition: IProviderModuleNaked['instantiatedFromDefinition'];
-    protected container: Container;
-    protected defaultScope: IProviderModuleNaked['defaultScope'];
-    protected onReady: IProviderModuleNaked['onReady'];
-    protected onDispose: IProviderModuleNaked['onDispose'];
-    protected moduleUtils: IProviderModuleNaked['moduleUtils'];
-    protected imports: IProviderModuleNaked['imports'];
-    protected providers: IProviderModuleNaked['providers'];
-    protected exports: IProviderModuleNaked['exports'];
-    protected registeredSideEffects: IProviderModuleNaked['registeredSideEffects'];
-    constructor(options: ProviderModuleOptions | IProviderModuleDefinition);
-    get<T>(provider: ProviderToken<T>, isOptional?: boolean): T;
-    getMany<D extends (ProviderModuleGetManyParam<any> | ProviderToken)[]>(...deps: D | unknown[]): ProviderModuleGetManySignature<D>;
-    lazyImport(...modules: ProviderModuleOrDefinition[]): void;
-    toNaked(): IProviderModuleNaked;
-    dispose(): Promise<void>;
-    toString(): string;
-    private setIdentifier;
-    private prepareContainer;
-    private injectImportedModules;
-    private injectProviders;
-    private registerSideEffect;
-    private invokeRegisteredSideEffects;
-    private removeRegisteredSideEffects;
-    private shouldThrowIfDisposed;
+    BeforeRemoveImport = 3,
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * Can be used to register a `middleware` which will be invoked right before removing a provider from _this_ module.
      *
-     * See {@link IProviderModuleNaked._internalInit}.
+     * **Note:** _The provided middleware `callback` must return a `boolean` where `true` means that_
+     * _the provider can be removed and `false` means to keep it._
      */
-    protected _internalInit(options: InternalInitOptions | IProviderModuleDefinition): IProviderModule;
+    BeforeRemoveProvider = 4,
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * Can be used to register a `middleware` which will be invoked right before removing an `ExportDefinition` from _this_ module.
      *
-     * See {@link IProviderModuleNaked._onBind}.
+     * **Note:** _The provided middleware `callback` must return a `boolean` where `true` means that_
+     * _the `ExportDefinition` can be removed and `false` means to keep it._
      */
-    protected _onBind<T>(provider: ProviderToken<T>, cb: () => Promise<void> | void): void;
+    BeforeRemoveExport = 5,
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * Can be used to register a `middleware` which will be invoked each time
+     * a _consumer_ `module` tries to access the `ExportDefinition` list of _this_ module to `get` a provider.
      *
-     * See {@link IProviderModuleNaked._onGet}.
+     * **Note:** _The provided middleware `callback` will be invoked for each `ProviderToken` of the `ExportsDefinition` list_
+     * _and must return a `boolean` where `true` means that the `ProviderToken` is authorized to be used by the importer module._
      */
-    protected _onGet<T>(provider: ProviderToken<T>, once: boolean, cb: () => Promise<void> | void): void;
+    OnExportAccess = 6
+}
+
+declare enum DefinitionEventType {
+    /** No-Operation, yet. */
+    Noop = 0,
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * A new `module` or `blueprint` has been added.
      *
-     * See {@link IProviderModuleNaked._onRebind}.
+     * **Note:** _The occurred change type is: `ModuleOrBlueprint`_
      */
-    protected _onRebind<T>(provider: ProviderToken<T>, cb: () => Promise<void> | void): void;
+    Import = 1,
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * A new `provider` has been added.
      *
-     * See {@link IProviderModuleNaked._onUnbind}.
+     * **Note:** _The occurred change type is: `DependencyProvider`_
      */
-    protected _onUnbind<T>(provider: ProviderToken<T>, cb: () => Promise<void> | void): void;
+    Provider = 2,
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * A `module` is retrieving from its container a `provider`.
      *
-     * See {@link IProviderModuleNaked._overwriteContainer}.
+     * **Note:** _The occurred change type is: `any`_
      */
-    protected _overwriteContainer(cb: () => Container): void;
+    GetProvider = 3,
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * A new `module` or `provider`  has been added to the `exports` definition.
      *
-     * See {@link IProviderModuleNaked.__bind}.
+     * **Note:** _The occurred change type is: `ExportDefinition`_
      */
-    protected __bind<T>(provider: ProviderToken<T>): BindToFluentSyntax<T>;
+    Export = 4,
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * A new `module` or `blueprint` has been added to the `exports` definition.
      *
-     * See {@link IProviderModuleNaked.__get}.
+     * **Note:** _The occurred change type is: `ModuleOrBlueprint`_
      */
-    protected __get<T>(provider: ProviderToken<T>, options?: GetOptions): T;
+    ExportModule = 5,
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * A new `provider` has been added to the `exports` definition.
      *
-     * See {@link IProviderModuleNaked.__getAsync}.
+     * **Note:** _The occurred change type is: `ProviderToken`_
      */
-    protected __getAsync<T>(provider: ProviderToken<T>, options?: GetOptions): Promise<T>;
+    ExportProvider = 6,
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * A `module` has been removed.
      *
-     * See {@link IProviderModuleNaked.__getAll}.
+     * **Note:** _The occurred change type is: `IProviderModule`_
      */
-    protected __getAll<T>(provider: ProviderToken<T>, options?: GetOptions): T[];
+    ImportRemoved = 7,
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * A `provider` has been removed.
      *
-     * See {@link IProviderModuleNaked.__getAllAsync}.
+     * **Note:** _The occurred change type is: `DependencyProvider`_
      */
-    protected __getAllAsync<T>(provider: ProviderToken<T>, options?: GetOptions): Promise<T[]>;
+    ProviderRemoved = 8,
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * An `ExportDefinition` has been removed.
      *
-     * See {@link IProviderModuleNaked.__isBound}.
+     * **Note:** _The occurred change type is: `ExportDefinition`_
      */
-    protected __isBound(provider: ProviderToken, options?: IsBoundOptions): boolean;
+    ExportRemoved = 9,
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * A `module` has been removed from the `export` definition.
      *
-     * See {@link IProviderModuleNaked.__isCurrentBound}.
+     * **Note:** _The occurred change type is: `IProviderModule`_
      */
-    protected __isCurrentBound(provider: ProviderToken, options?: IsBoundOptions): boolean;
+    ExportModuleRemoved = 10,
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * A `provider` has been removed from the `export` definition.
      *
-     * See {@link IProviderModuleNaked.__takeSnapshot}.
+     * **Note:** _The occurred change type is: `ProviderToken`_
      */
-    protected __takeSnapshot(): void;
+    ExportProviderRemoved = 11
+}
+
+/** See {@link https://inversify.io/docs/api/decorator/#injectable} for more details. */
+declare function Injectable(scope?: InjectionScope): ClassDecorator;
+
+type AsyncMethod<T = void> = () => Promise<T>;
+
+type ProviderToken<T = any> = ProviderIdentifier<T> | DependencyProvider<T>;
+type DependencyProvider<T = any> = Class<T> | Function | ProviderClassToken<T> | ProviderValueToken<T> | ProviderFactoryToken<T>;
+type ProviderClassToken<T> = (ProviderOptions<T> & ProviderScopeOption) & {
+    /** The `class` to be injected. */
+    useClass: Class<T>;
+};
+type ProviderValueToken<T> = ProviderOptions<T> & {
+    /** The _(constant)_ `value` to be injected. */
+    useValue: T;
+};
+type ProviderFactoryToken<T> = (ProviderOptions<T> & ProviderScopeOption) & {
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * Factory `function` that returns an instance of the provider to be injected.
      *
-     * See {@link IProviderModuleNaked.__restoreSnapshot}.
-     */
-    protected __restoreSnapshot(): void;
-    /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * @example
+     * ```ts
+     * const connectionProvider = {
+     *   provide: 'CONNECTION',
+     *   useFactory: (optionsService: OptionsService, secondService: SecondService) => {
+     *     const options = optionsService.get();
      *
-     * See {@link IProviderModuleNaked.__rebind}.
+     *     return new DatabaseConnection(options);
+     *   },
+     *   // `inject` is optional.
+     *   inject: [OptionsService, SecondService]
+     * };
+     * ```
      */
-    protected __rebind<T>(provider: ProviderToken<T>): Promise<BindToFluentSyntax<T>>;
+    useFactory: (...providers: any[]) => T;
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * Optional list of providers to be injected into the context of the Factory `function`.
      *
-     * See {@link IProviderModuleNaked.__rebindSync}.
-     */
-    protected __rebindSync<T>(provider: ProviderToken<T>): BindToFluentSyntax<T>;
-    /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * **Note:** _The current module container context is available too._
      *
-     * See {@link IProviderModuleNaked.__unbind}.
+     * ```ts
+     * ProviderModule.create({
+     *   id: 'FactoryProviderModule',
+     *   providers: [
+     *     DatabaseService,
+     *     {
+     *       provide: 'DATABASE_SECRET',
+     *       useFactory: (dbService: DatabaseService) => {
+     *         // Here you have access to the already resolved `DatabaseService` of the `FactoryProviderModule`.
+     *         return dbService.getSecret();
+     *       },
+     *       inject: [DatabaseService]
+     *     }
+     *   ]
+     * });
+     * ```
      */
-    protected __unbind(provider: ProviderToken): Promise<void>;
+    inject?: ProviderIdentifier[];
+};
+type ProviderIdentifier<T = any> = Class<T> | Function | symbol | string;
+interface ProviderOptions<T> {
+    /** The injection `token`.  */
+    provide: ProviderIdentifier<T>;
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * Specifies whether the binding is used to provide a resolved value for the given {@link ProviderToken | provider}.
      *
-     * See {@link IProviderModuleNaked.__unbindSync}.
+     * See {@link https://inversify.io/docs/api/binding-syntax/#bindwhenfluentsyntax} for more details.
      */
-    protected __unbindSync(provider: ProviderToken): void;
+    when?: (metadata: BindingConstraints) => boolean;
+}
+interface ProviderScopeOption {
     /**
-     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     * The scope determines the caching strategy used to decide whether the service should be resolved or a cached value should be provided.
+     *
+     * If not provided, it'll default to the `ProviderModule` default scope.
      *
-     * See {@link IProviderModuleNaked.__unbindAll}.
+     * See {@link https://inversify.io/docs/fundamentals/binding/#scope} for more details..
      */
-    protected __unbindAll(): Promise<void>;
+    scope?: InjectionScope;
 }
 
-/**
- * Class of the {@link AppModule} instance.
- *
- * **You shouldn't initialize a new instance of this class, please use the {@link AppModule} instance!**
- */
-declare class GlobalAppModule extends ProviderModule implements IAppModule {
-    _strict: AppModuleOptions['_strict'];
-    private nakedModule;
-    private isLoaded;
-    constructor();
-    register<AsNaked extends boolean = false>(options: AppModuleOptions): AsNaked extends false ? IAppModule : IAppModule & IProviderModuleNaked;
-    lazyImport(...modules: ProviderModuleOrDefinition[]): void;
-    toNaked(): IAppModule & IProviderModuleNaked;
-    dispose(): Promise<void>;
-    /** **Internally used, do not use!** */
-    _importWithoutSecondaryImportCheck(...modules: ProviderModuleOrDefinition[]): void;
-    private checkIfRegisteredModulesHaveGlobalMark;
+declare class ModuleContainer {
+    readonly container: Container;
+    private readonly providerModule;
+    constructor(providerModule: ProviderModule, inversifyParentContainer?: Container);
+    get<T, IsOptional extends boolean | undefined = undefined, AsList extends boolean | undefined = undefined>(provider: ProviderToken<T>, isOptional?: IsOptional, asList?: AsList): ProviderModuleGetReturn<T, IsOptional, AsList>;
+    getMany<D extends (ProviderModuleGetManyParam<any> | ProviderToken)[]>(...deps: D | unknown[]): ProviderModuleGetManyReturn<D>;
+    bindToContainer<T>(provider: DependencyProvider<T>): void;
+    setBindingScope<T>(provider: ProviderToken<T>, binding: BindInWhenOnFluentSyntax<T>): BindWhenOnFluentSyntax<T>;
+    dispose(): void;
+    private getProvider;
 }
-/**
- * Special instance of {@link ProviderModule} which acts as the global module of your application in which you can inject any provider
- * which must be available through your entire application.
- *
- * The registered providers will automatically be available inside all the modules.
- *
- * @example
- * ```ts
- * // The `register` method must be invoked only once during your application life cycle!
- * AppModule.register({
- *   imports: [ConfigModule, ApiModule, UserModule, DatabaseModule],
- *   providers: [DummyService],
- * });
- * ```
- */
-declare const AppModule: GlobalAppModule;
 
-/**
- * Can be used when you _don't_ want to initialize a `ProviderModule` eagerly as each `ProviderModule` has its own _(InversifyJS)_ container
- * initialized as soon as you do `new ProviderModule({...})`.
- *
- * The {@link ProviderModuleDefinition} allows you to just _define_ the `ProviderModule` options so you can _import_ it later into different modules.
- *
- * You can always edit a property of the definition after instantiation by doing:
- *
- * ```ts
- * const GarageModuleDefinition = new ProviderModuleDefinition({ identifier: 'GarageModuleDefinition' });
- *
- * // Later in your code
- *
- * GarageModuleDefinition.imports = [...GarageModuleDefinition.imports, PorscheModule, FerrariModuleDefinition];
- *
- * // ...
- *
- * const GarageModule = new ProviderModule(GarageModuleDefinition);
- *
- * // or
- *
- * ExistingModule.lazyImport(GarageModuleDefinition);
- * ```
- *
- * **Note:** _This means that you can't expect to be able to inject dependencies from a {@link ProviderModuleDefinition}_
- * _as how you would do with an instance of a `ProviderModule`._
- */
-declare class ProviderModuleDefinition implements IProviderModuleDefinition {
-    identifier: IProviderModuleDefinition['identifier'];
-    imports: IProviderModuleDefinition['imports'];
-    providers: IProviderModuleDefinition['providers'];
-    exports: IProviderModuleDefinition['exports'];
-    defaultScope: IProviderModuleDefinition['defaultScope'];
-    isGlobal: IProviderModuleDefinition['isGlobal'];
-    onReady: IProviderModuleDefinition['onReady'];
-    onDispose: IProviderModuleDefinition['onDispose'];
-    constructor(moduleOptions: ProviderModuleOptions);
-    getDefinition(): ProviderModuleOptions;
-    clone(definition?: Partial<ProviderModuleOptions>): IProviderModuleDefinition;
-    toString(): string;
-    private checkIfShouldBeAddedToTheGlobalRegister;
+declare class ImportedModuleContainer {
+    get moduleDef(): ModuleDefinition<true>;
+    /** The {@link ProviderModule} which imported {@link providerModule | this} module. */
+    private readonly importedIntoModule;
+    private readonly providerModule;
+    private readonly proxyContainer;
+    private proxyContainerOptions;
+    constructor(importedIntoModule: ProviderModule, providerModule: ProviderModule);
+    dispose(): void;
+    private buildProxyContainer;
+    private proxyProviderIdentifier;
+    private unproxyProviderIdentifier;
+    private traverseExportGraph;
 }
 
-interface ProviderModuleOptions {
-    /** The module unique `ID`. */
-    identifier: symbol | string;
-    /** Import additional {@link IProviderModule | modules} into _this_ module. */
-    imports?: ProviderModuleOrDefinition[];
-    /** The {@link DependencyProvider | providers} that will be instantiated by the container and that may be shared at least across _this_ module. */
-    providers?: DependencyProvider[];
-    /**
-     * The subset of {@link ProviderToken | providers} or {@link IProviderModule | modules} that
-     * are provided by _this_ module and should be available in other modules which import _this_ module.
+declare class Signal<T> {
+    private value;
+    private readonly subscribers;
+    constructor(initialValue: T);
+    /** Can be used to `emit` a _new_ value and notify the _subscribers_. */
+    emit(newValue: T): void;
+    /** Can be used to retrieve the _current_ value of the {@link Signal} imperatively. */
+    get(): T;
+    /**
+     * Can be used to `subscribe` to the emitted values of this {@link Signal}.
      *
-     * **Note:** _Supports lazy exports, see {@link LazyExport}._
+     * @param callback The `callback` which will be invoked when a _new_ value is emitted.
+     * @param invokeImmediately When set to `true` it'll invoke the provided {@link callback} immediately with the latest value available. _(defaults to `false`)_
      */
-    exports?: ExportsList;
+    subscribe(callback: SignalCallback<T>, invokeImmediately?: boolean): () => void;
+    /** Disposes of the internal references. */
+    dispose(): void;
+}
+type SignalCallback<T> = (value: T) => void | Promise<void>;
+
+interface IDynamicModuleDefinition {
+    /** Can be used to _subscribe_ in real-time to the _definition_ changes. */
+    readonly subscribe: Signal<DefinitionEvent>['subscribe'];
     /**
-     * The default {@link InjectionScope} to be used when a {@link ProviderToken} does not have a defined `scope`.
+     * Can be used to `import` a new {@link moduleOrBlueprint} into the current {@link IProviderModule | Module}.
      *
-     * Defaults to {@link InjectionScope.Singleton}.
+     * @param moduleOrBlueprint Either the `Module` or the `ModuleBlueprint` to be imported.
+     * @param addToExports When set to `true` it'll also `export` the {@link moduleOrBlueprint}. _(defaults to `false`)_
      */
-    defaultScope?: InjectionScope;
+    addImport(moduleOrBlueprint: ModuleOrBlueprint, addToExports?: boolean): void;
     /**
-     * When a module is marked as `global`, it means that it is expected to be _imported_ into the `AppModule`.
+     * Can be used to _lazily_ `import` a new {@link module} into the current {@link IProviderModule | Module}.
      *
-     * **Note:** _Importing a `global` module into a `scoped` module will automatically import it into the `AppModule` rather than the scoped module itself!_
+     * **Note:** _This is useful when you want to lazy import a module from within another file._
      *
-     * Expect an exception to be thrown:
-     * - If a `module` marked as global is **not** imported into the `AppModule`.
-     * - If a `module` **not** marked as global _is_ imported into the `AppModule`
+     * ```ts
+     * addImportLazy(async () => import('./lazy.module'));
+     * ```
      *
-     * Defaults to `false`.
+     * @param lazyCb An `async` callback which will resolve the {@link IProviderModule | Module} to be imported.
+     * @param addToExports When set to `true` it'll also `export` the {@link module}. _(defaults to `false`)_
      */
-    isGlobal?: boolean;
+    addImportLazy(lazyCb: AsyncMethod<IProviderModule>, addToExports?: boolean): Promise<void>;
     /**
-     * Callback which will be invoked once the module container has been initialized
-     * and the providers resolved.
-     *
-     * **This happens only once, when the {@link IProviderModule | ProviderModule} has been bootstrapped!**
+     * Can be used to `bind` a new {@link provider} to the {@link IProviderModule | Module}'s `container`.
      *
-     * @param module The instance of the {@link IProviderModule | module}.
+     * @param provider The {@link DependencyProvider | Provider} to add.
+     * @param addToExports When set to `true` it'll also `export` the {@link module}. _(defaults to `false`)_
      */
-    onReady?: (module: IProviderModule) => Promise<void>;
+    addProvider<T>(provider: DependencyProvider<T>, addToExports?: boolean): void;
     /**
-     * Callback which will be invoked when the module dispose method is invoked.
+     * Can be used to _lazily_ `bind` a new {@link provider} to the {@link IProviderModule | Module}'s `container`.
+     *
+     * **Note:** _This is useful when you want to lazy import a provider from within another file._
      *
-     * @returns See {@link OnDisposeOptions}.
+     * ```ts
+     * addImportLazy(async () => import('./lazy.provider'));
+     * ```
+     *
+     * @param lazyCb An `async` callback which will resolve the {@link DependencyProvider | Provider} to add.
+     * @param addToExports When set to `true` it'll also `export` the {@link module}. _(defaults to `false`)_
      */
-    onDispose?: () => OnDisposeOptions;
-}
-interface ProviderModuleOptionsInternal {
-    isAppModule?: boolean;
-    instantiatedFromDefinition?: boolean;
-    isDisposed?: boolean;
-    /** Can be used to manually provide the {@link IAppModule} instance. */
-    appModule?: () => GlobalAppModule;
-    /** Can be used to manually provide a {@link Container} instance. */
-    container?: () => Container;
-}
-type ExportsList = (StaticExport | LazyExport)[];
-type StaticExport = ProviderToken | ProviderModuleOrDefinition;
-type LazyExport = (
-/** The {@link IProviderModule | module} which is importing _this_ module. */
-importerModule: IProviderModule) => StaticExport | void;
-type OnDisposeOptions = RequireAtLeastOne<{
+    addProviderLazy<T>(lazyCb: AsyncMethod<DependencyProvider<T>>, addToExports?: boolean): Promise<void>;
     /**
-     * It'll be invoked _before_ the dispose process starts.
+     * Can be used to remove an `import` from the _current_ {@link IProviderModule | Module}.
+     * It'll also automatically remove it from the `exports` definition.
      *
-     * @param module The {@link IProviderModule | module} instance.
+     * **Note:** _You can always add it back with the {@link addImport} or {@link addImportLazy} methods._
+     *
+     * @param module The {@link IProviderModule | Module} to be removed.
      */
-    before: (module: IProviderModule) => void | Promise<void>;
+    removeImport(module: IProviderModule): boolean;
     /**
-     * It'll be invoked _after_ the dispose process ended.
+     * Can be used to remove a `provider` from the _current_ {@link IProviderModule | Module}'s `container`.
+     * It'll also automatically remove it from the `exports` definition.
      *
-     * **Note:** _At this point the internal container has been destroyed and it'll be `null` when trying to access it._
+     * **Note:** _You can always add it back with the {@link addProvider} or {@link addProviderLazy} methods._
      *
-     * @param module The {@link IProviderModule | module} instance.
+     * @param provider The {@link DependencyProvider | Provider} to be removed.
      */
-    after: (module: IProviderModule) => void | Promise<void>;
-}>;
-
-interface IProviderModuleDefinition extends ProviderModuleOptions {
-    /** Returns the {@link ProviderModuleOptions | definition}. */
-    getDefinition(): ProviderModuleOptions;
+    removeProvider<T>(provider: DependencyProvider<T>): boolean;
     /**
-     * Can be used to _clone_ the instance of this {@link IProviderModuleDefinition | ModuleDefinition}.
+     * Can be used to remove a {@link IProviderModule | Module} or {@link DependencyProvider | Provider} from
+     * the `exports` definition of this `module`.
      *
-     * @param definition Optionally you can overwrite the definition of the clone before being returned.
+     * **Note:** _Consumers which already consumed the {@link exportDefinition} may still old a reference onto it._
      *
-     * ```ts
-     * const CarModuleDefinition = new ProviderModuleDefinition({
-     *   identifier: 'CarModuleDefinition',
-     *   providers: [CarService],
-     * });
-     *
-     * const CarModuleDefinitionMocked = CarModuleDefinition.clone({
-     *   identifier: 'CarModuleDefinitionMocked',
-     *   providers: [{ provide: CarService, useClass: CarServiceMocked }]
-     * });
-     * ```
+     * @param exportDefinition The {@link ExportDefinition} to be removed.
      */
-    clone(definition?: Partial<ProviderModuleOptions>): IProviderModuleDefinition;
-    /** Returns the {@link ProviderModuleOptions.identifier | identifier}. */
-    toString(): string;
+    removeFromExports(exportDefinition: ExportDefinition): boolean;
+}
+interface DefinitionEvent {
+    /** The {@link DefinitionEventType}. */
+    type: DefinitionEventType;
+    /** The occurred change. */
+    change: any;
 }
 
-/**
- * Class containing an internal set of `utils`.
- *
- * Each {@link IProviderModuleNaked.moduleUtils | ProviderModule} instance has its own {@link ProviderModuleUtils} property instance.
- */
-declare class ProviderModuleUtils {
-    /** The low-level InversifyJS {@link Container} owned by {@link ProviderModuleUtils.module | module}. */
-    get container(): Container;
-    readonly appModule: GlobalAppModule;
-    /** The parent {@link IProviderModule | ProviderModule} of `this` instance. */
-    readonly module: IProviderModule;
-    readonly moduleNaked: IProviderModuleNaked;
-    constructor(module: IProviderModule, internalOptions: ProviderModuleOptionsInternal);
-    /**
-     * Low-level method which can be used to manually register _(bind)_ a new {@link provider} into the {@link ProviderModuleUtils.module | module} container.
-     *
-     * **Note:** _You shouldn't directly use this to register providers as they will not appear_
-     * _into the module's `imports` and `exports` arrays! Therefore leading to unexpected bugs and confusion!_
-     *
-     * @param provider The {@link ProviderToken | provider} to register.
-     * @param defaultScope Optionally provide the default {@link InjectionScope} to use when applicable.
-     * @returns `true` when the {@link provider} has been bound otherwhise `false`.
-     */
-    bindToContainer<T>(provider: DependencyProvider<T>, defaultScope: InjectionScope): boolean;
-    private checkIfShouldBeAddedToTheGlobalRegister;
-    private bindSelfTokenToContainer;
-    private bindClassTokenToContainer;
-    private bindValueTokenToContainer;
-    private bindFactoryTokenToContainer;
-    /** Sets the {@link InjectionScope} of a bound {@link provider}. */
-    private setBindingScope;
-    /** Sets the `when` clause of a bound {@link provider}. */
-    private setWhenBinding;
-    /** Sets the `activation` and `deactivation` events of a bound {@link provider}. */
-    private setBindingOnEvent;
+declare class DynamicModuleDefinition implements IDynamicModuleDefinition {
+    get moduleContainer(): ModuleContainer;
+    get subscribe(): IDynamicModuleDefinition['subscribe'];
+    readonly moduleDef: ModuleDefinition<true>;
+    readonly event$: Signal<DefinitionEvent>;
+    private readonly providerModule;
+    private emittingModules;
+    private importedModuleSubscriptions;
+    constructor(providerModule: ProviderModule);
+    addImport(moduleOrBlueprint: ModuleOrBlueprint, addToExports?: boolean): void;
+    addImportLazy(lazyCb: AsyncMethod<ProviderModule>, addToExports?: boolean): Promise<void>;
+    addProvider<T>(provider: DependencyProvider<T>, addToExports?: boolean): void;
+    addProviderLazy<T>(lazyCb: AsyncMethod<DependencyProvider<T>>, addToExports?: boolean): Promise<void>;
+    removeImport(module: IProviderModule): boolean;
+    removeProvider<T>(provider: DependencyProvider<T>): boolean;
+    removeFromExports(exportDefinition: ExportDefinition): boolean;
+    emitEventSafely(event: DefinitionEvent): void;
+    dispose(): void;
+    private buildInitialDefinition;
+    private createImportedModuleContainer;
+    private subscribeToImportedModuleEvents;
+    private unsubscribeFromImportedModuleEvents;
 }
 
-/** Can be used to publicly expose internal properties and methods of an {@link IProviderModule} instance. */
-interface IProviderModuleNaked extends IProviderModule {
-    /** It'll be `true` when the current module is the global `AppModule`. */
-    readonly isAppModule: boolean;
-    /** It'll be `true` when the `module` has been instantiated from a `ProviderModuleDefinition` instance. */
-    readonly instantiatedFromDefinition: boolean;
-    /** The low-level `InversifyJS` {@link https://inversify.io/docs/api/container/ | container} instance. */
-    readonly container: Container;
-    /** The default injection scope of this module. */
-    readonly defaultScope: {
-        /** Scope from `xInjection` {@link InjectionScope} enum. */
-        native: InjectionScope;
-        /** Scope from `InversifyJS` {@link BindingScope} string union. */
-        inversify: BindingScope;
-    };
-    /** Instance of the {@link ProviderModuleUtils}. */
-    readonly moduleUtils: ProviderModuleUtils;
-    /** The {@link DependencyProvider | providers} resolved by this module. */
-    readonly providers: DependencyProvider[];
-    /** What is exported into this module. */
-    readonly imports: ProviderModuleOrDefinition[];
-    /** What is exported from this module. */
-    readonly exports: ExportsList;
-    /** The registered `callback` which will be invoked when the internal initialization process has been completed. */
-    readonly onReady: ProviderModuleOptions['onReady'];
-    /** The registered `callback` which will be invoked when the {@link _dispose} method is invoked. */
-    readonly onDispose: ProviderModuleOptions['onDispose'];
-    readonly registeredSideEffects: RegisteredSideEffects;
-    /** It'll _completely_ re-init the `module` with the provided {@link InternalInitOptions | options}. */
-    _internalInit(options: InternalInitOptions): IProviderModule;
-    /**
-     * Can be used to execute the provided {@link cb | callback} whenever a _new_ {@link https://inversify.io/docs/fundamentals/binding/ | binding}
-     * is registered for the {@link provider}.
-     *
-     * @param provider The {@link ProviderToken}.
-     * @param cb The `callback` to be invoked.
-     */
-    _onBind<T>(provider: ProviderToken<T>, cb: () => Promise<void> | void): void;
+interface IMiddlewaresManager {
+    /** See {@link MiddlewareType} for more info. */
+    add<T extends MiddlewareType>(type: T, cb: AddMiddlewareCallbackType<T>): void;
+}
+type AddMiddlewareCallbackType<T extends MiddlewareType> = T extends MiddlewareType.BeforeAddImport ? (module: IProviderModule) => IProviderModule | boolean : T extends MiddlewareType.BeforeAddProvider ? (provider: ProviderToken) => ProviderToken | boolean : T extends MiddlewareType.BeforeGet ? (provider: any, providerToken: ProviderToken, inject: ModuleContainer['getProvider']) => any : T extends MiddlewareType.BeforeRemoveImport ? (module: IProviderModule) => boolean : T extends MiddlewareType.BeforeRemoveProvider ? (dependencyProvider: DependencyProvider<any>) => boolean : T extends MiddlewareType.BeforeRemoveExport ? (providerOrModule: ExportDefinition) => boolean : T extends MiddlewareType.OnExportAccess ? (importerModule: IProviderModule, currentExport: ProviderToken) => boolean : never;
+
+declare class MiddlewaresManager implements IMiddlewaresManager {
+    private middlewaresMap;
+    private readonly providerModule;
+    constructor(providerModule: ProviderModule);
+    add<T extends MiddlewareType>(type: MiddlewareType, cb: AddMiddlewareCallbackType<T>): void;
+    applyMiddlewares<T>(type: MiddlewareType, ...args: any[]): T;
+    clear(): void;
+    dispose(): void;
+}
+
+interface ModuleBlueprintOptions {
     /**
-     * Can be used to execute the provided {@link cb | callback} whenever the
-     * {@link IProviderModule.get | get} method is invoked.
+     * When set to `false` you'll have to _manually_ import this blueprint
+     * into the `AppModule` to make it available across all your modules.
      *
-     * @param provider The {@link ProviderToken}.
-     * @param once When set to `true` it'll invoke the provided {@link cb | callback} only once.
-     * @param cb The `callback` to be invoked.
+     * Defaults to `true`.
      */
-    _onGet<T>(provider: ProviderToken<T>, once: boolean, cb: () => Promise<void> | void): void;
+    autoImportIntoAppModuleWhenGlobal?: boolean;
+}
+
+declare class ProviderModuleBlueprint {
+    id: ProviderModuleOptions['id'];
+    imports?: ProviderModuleOptions['imports'];
+    providers?: ProviderModuleOptions['providers'];
+    exports?: ProviderModuleOptions['exports'];
+    defaultScope?: ProviderModuleOptions['defaultScope'];
+    isGlobal?: ProviderModuleOptions['isGlobal'];
+    onReady?: ProviderModuleOptions['onReady'];
+    onReset?: ProviderModuleOptions['onReset'];
+    onDispose?: ProviderModuleOptions['onDispose'];
+    private readonly blueprintOptions;
+    constructor(options: ProviderModuleOptions, blueprintOptions?: ModuleBlueprintOptions);
+    /** Can be used to update the {@link ProviderModuleBlueprint | Blueprint} definition. */
+    updateDefinition(options: ProviderModuleOptions): this;
+    /** Returns the {@link ProviderModuleOptions} of this {@link ProviderModuleBlueprint | Blueprint}. */
+    getDefinition(): ProviderModuleOptions;
     /**
-     * Can be used to execute the provided {@link cb | callback} whenever an existing {@link https://inversify.io/docs/fundamentals/binding/ | binding}
-     * is re-registered for the {@link provider}.
+     * Can be used to instantiate a _new_ `blueprint` with the same exact options as _this_ one.
      *
-     * @param provider The {@link ProviderToken}.
-     * @param cb The `callback` to be invoked.
+     * **Note:** _Everything is deep cloned, you can safely overwrite all the properties of the cloned instance._
      */
-    _onRebind<T>(provider: ProviderToken<T>, cb: () => Promise<void> | void): void;
+    clone(): ProviderModuleBlueprint;
+    private convertToModuleAndInjectIntoAppModuleIfGlobal;
+}
+
+declare abstract class IProviderModule {
+    /** The `identifier` of this {@link IProviderModule | Module}. */
+    readonly id: ModuleIdentifier;
     /**
-     * Can be used to execute the provided {@link cb | callback} whenever a {@link provider} is `unbound`.
-     *
-     * **Note:** _All the {@link _onBind}, {@link _onGet}, {@link _onRebind} and {@link _onUnbind} registered callbacks will be removed_
+     * The {@link ModuleDefinition} of this {@link IProviderModule | Module}.
      *
-     * @param provider The {@link ProviderToken}.
-     * @param cb The `callback` to be invoked.
+     * **Note:** _You shouldn't manually modify the {@link ModuleDefinition}!_
+     * _Interact via the {@link update} methods instead._
      */
-    _onUnbind<T>(provider: ProviderToken<T>, cb: () => Promise<void> | void): void;
+    readonly definition: ModuleDefinition<true>;
+    /** The {@link IDynamicModuleDefinition} of this {@link IProviderModule | Module}. */
+    readonly update: IDynamicModuleDefinition;
+    /** The {@link IMiddlewaresManager} of this {@link IProviderModule | Module}. */
+    readonly middlewares: IMiddlewaresManager;
+    /** It'll be `true` after the {@link dispose} method has been invoked. */
+    readonly isDisposed: boolean;
     /**
-     * Internal method which can be used to completely overwrite the module {@link container}
-     * with the one provided.
+     * Instantiates a new `instance` of the {@link IProviderModule} class.
      *
-     * @param cb Callback which when invoked must return an instance of the {@link Container}.
-     */
-    _overwriteContainer(cb: () => Container): void;
-    /**
-     * Binds a {@link ProviderToken | provider}.
+     * **Note:** _Check also the {@link blueprint} method._
      *
-     * See {@link https://inversify.io/docs/api/container/#bind | Container.bind} for more details.
+     * @param options The {@link ProviderModuleOptions}.
      */
-    __bind<T>(provider: ProviderToken<T>): BindToFluentSyntax<T>;
+    static create(options: ProviderModuleOptions): IProviderModule;
     /**
-     * Resolves a dependency by its runtime identifier.
-     * The runtime identifier must be associated with only one binding and the binding must be synchronously resolved,
-     * otherwise an error is thrown.
+     * Can be used when you _don't_ want to initialize a `ProviderModule` eagerly as each `ProviderModule` has its own container
+     * initialized as soon as you do `ProviderModule.create({...})`.
      *
-     * @param provider The {@link ProviderToken}.
-     * @param options The {@link GetOptions}.
-     * @returns Either the {@link T | dependency} or `undefined` if {@link GetOptions.optional} is set to `true`.
+     * The {@link ProviderModuleBlueprint} allows you to just _define_ a `blueprint` of a `ProviderModule`,
+     * you can then decide to either _instantiate_ it or _import_ as it is into different modules _(or blueprints)_.
      *
-     * See {@link https://inversify.io/docs/api/container/#get | Container.get} for more details.
-     */
-    __get<T>(provider: ProviderToken<T>, options?: GetOptions): T;
-    /**
-     * Resolves a dependency by its runtime identifier.
-     * The runtime identifier must be associated with only one binding,
-     * otherwise an error is thrown.
+     * **Note:** _As soon as you import a `blueprint` into a `module`, it'll be automatically transformed into a {@link IProviderModule} instance!_
+     * _Also keep in mind that editing the `blueprint` after it has been consumed by a `module` will not propagate the changes to the consumer `module`!_
      *
-     * @param provider The {@link ProviderToken}.
-     * @param options The {@link GetOptions}.
-     * @returns Either the {@link T | dependency} or `undefined` if {@link GetOptions.optional} is set to `true`.
+     * **[WARNING]**: When you import the same `blueprint` into different modules, each `module` will create a new `module` instance
+     * based on that specific `blueprint`, this may not seem obvious at first, but it happens because a `blueprint` is just that, a template defining the options
+     * which will be used to build a `module`.
+     * This means that if a `blueprint` exports a `singleton` provider, when imported into two separate modules, each `module` will have _its own_ instance of that
+     * specific `singleton` provider!
+     * You should also keep in mind that once a `blueprint` has been encapsulated into a `module`, it can't be removed anymore as you can do with the modules!
      *
-     * See {@link https://inversify.io/docs/api/container/#getasync | Container.getAsync} for more details.
-     */
-    __getAsync<T>(provider: ProviderToken<T>, options?: GetOptions): Promise<T>;
-    /** See {@link https://inversify.io/docs/api/container/#getall | Container.getAll} for more details. */
-    __getAll<T>(provider: ProviderToken<T>, options?: GetOptions): T[];
-    /** See {@link https://inversify.io/docs/api/container/#getallasync | Container.getAllAsync} for more details. */
-    __getAllAsync<T>(provider: ProviderToken<T>, options?: GetOptions): Promise<T[]>;
-    /**
-     * Can be used to check if there are registered bindings for the {@link provider | provider}.
+     * Why should you use a {@link ProviderModuleBlueprint}?
      *
-     * See {@link https://inversify.io/docs/api/container/#isbound | Container.isBound} for more details.
-     */
-    __isBound(provider: ProviderToken, options?: IsBoundOptions): boolean;
-    /**
-     * Can be useed to check if there are registered bindings for the {@link provider | provider} only in the current container.
+     * - To _define module configurations upfront_ without incurring the cost of immediate initialization.
+     * - To reuse module _definitions across_ different parts of your application while maintaining isolated instances.
+     * - To _compose modules flexibly_, allowing you to adjust module dependencies dynamically before instantiation.
      *
-     * See {@link https://inversify.io/docs/api/container/#iscurrentbound | Container.isCurrentBound} for more details.
-     */
-    __isCurrentBound(provider: ProviderToken, options?: IsBoundOptions): boolean;
-    /**
-     * Save the state of the container to be later restored with the restore method.
+     * You can always edit a property of the `blueprint` after creating it by doing:
      *
-     * See {@link https://inversify.io/docs/api/container/#snapshot | Container.snapshot} for more details.
-     */
-    __takeSnapshot(): void;
-    /**
-     * Restore container state to last snapshot.
+     * ```ts
+     * const GarageModuleBlueprint = ProviderModule.blueprint({ id: 'GarageModuleBlueprint' });
      *
-     * See {@link https://inversify.io/docs/api/container/#restore | Container.restore} for more details.
-     */
-    __restoreSnapshot(): void;
-    /**
-     * Convenience method that unbinds a {@link ProviderToken | provider} and then creates a new binding for it.
-     * This is equivalent to calling await `container.unbind` followed by `container.bind`, but in a single method.
+     * // Later in your code
      *
-     * @param provider The {@link ProviderToken}.
-     * @returns A {@link BindToFluentSyntax | binding builder} to continue configuring the new binding.
+     * GarageModuleBlueprint.imports = [...GarageModuleBlueprint.imports, PorscheModule, FerrariModuleBlueprint];
      *
-     * See {@link https://inversify.io/docs/api/container/#rebind | Container.rebind} for more details.
-     */
-    __rebind<T>(provider: ProviderToken<T>): Promise<BindToFluentSyntax<T>>;
-    /**
-     * Synchronous version of {@link __rebindProvider}. Unbinds a {@link ProviderToken | provider} synchronously and then creates a new binding for it.
-     * Will throw an error if the unbind operation would be asynchronous.
+     * // ...
      *
-     * @param provider The {@link ProviderToken}.
-     * @returns A {@link BindToFluentSyntax | binding builder} to continue configuring the new binding.
+     * const GarageModule = ProviderModule.create(GarageModuleBlueprint);
      *
-     * See {@link https://inversify.io/docs/api/container/#rebindsync | Container.rebindSync} for more details.
-     */
-    __rebindSync<T>(provider: ProviderToken<T>): BindToFluentSyntax<T>;
-    /**
-     * Removes **all** the associated bindings with the {@link provider} from the container.
+     * // or
      *
-     * This will result in the {@link https://inversify.io/docs/fundamentals/lifecycle/deactivation/ | deactivation process}.
+     * ExistingModule.update.addImport(GarageModuleBlueprint);
+     * ```
      *
-     * See {@link https://inversify.io/docs/api/container/#unbind | Container.unbind} for more details.
+     * @param moduleOptions The {@link ProviderModuleOptions}.
+     * @param blueprintOptions Options specific to the {@link ProviderModuleBlueprint | Blueprint} instance, see {@link ModuleBlueprintOptions}.
      */
-    __unbind(provider: ProviderToken): Promise<void>;
+    static blueprint(moduleOptions: ProviderModuleOptions, blueprintOptions?: ModuleBlueprintOptions): ProviderModuleBlueprint;
     /**
-     * Removes **all** the associated bindings with the {@link provider} from the container synchronously.
-     * This method works like {@link __unbind} but does not return a Promise.
-     * If the unbinding operation would be asynchronous (e.g. due to deactivation handlers),
-     * it will throw an error. Use this method when you know the operation won't involve async deactivations.
+     * Can be used to check if this {@link IProviderModule | Module} has a specific `module` imported into it.
      *
-     * This will result in the {@link https://inversify.io/docs/fundamentals/lifecycle/deactivation/ | deactivation process}.
-     *
-     * See {@link https://inversify.io/docs/api/container/#unbindsync | Container.unbindSync} for more details.
+     * @param idOrModule Either the {@link ModuleIdentifier} or the {@link IProviderModule} itself.
      */
-    __unbindSync(provider: ProviderToken): void;
+    isImportingModule(idOrModule: ModuleIdentifier | IProviderModule): boolean;
     /**
-     * Remove all bindings bound in this container.
-     *
-     * This will result in the {@link https://inversify.io/docs/fundamentals/lifecycle/deactivation/ | deactivation process}.
+     * Can be used to check if this {@link IProviderModule | Module} has a specific `provider` bound to _its_ container.
      *
-     * See {@link https://inversify.io/docs/api/container/#unbindall | Container.unbindAll} for more details.
+     * @param provider The {@link DependencyProvider | Provider} to lookup for.
      */
-    __unbindAll(): Promise<void>;
-}
-type InternalInitOptions = Except<ProviderModuleOptions & ProviderModuleOptionsInternal, 'identifier' | 'isAppModule'>;
-type RegisteredSideEffects = Map<ProviderToken, {
-    onBindEffects: OnBindEffects[];
-    onGetEffects: OnGetEffects[];
-    onRebindEffects: OnRebindEffects[];
-    onUnbindEffects: OnUnbindEffects[];
-}>;
-type OnBindEffects = () => Promise<void> | void;
-type OnGetEffects = {
-    once: boolean;
-    invoked: boolean;
-    cb: () => Promise<void> | void;
-};
-type OnRebindEffects = () => Promise<void> | void;
-type OnUnbindEffects = {
-    registerModuleId?: ModuleIdentifier;
-    cb: () => Promise<void> | void;
-};
-
-interface IProviderModule {
-    /** The module unique ID. */
-    readonly identifier: ModuleIdentifier;
-    /** See {@link ProviderModuleOptions.isGlobal}. */
-    readonly isGlobal: ProviderModuleOptions['isGlobal'];
-    readonly isDisposed: boolean;
+    hasProvider<T>(provider: DependencyProvider<T>): boolean;
     /**
-     * Can be used to retrieve a resolved `dependency` from the module container.
+     * Can be used to retrieve a {@link provider} from the module container.
      *
      * @param provider The {@link ProviderToken}.
-     * @param isOptional When set to `false` _(default)_ an exception will be thrown when the {@link provider} isn't bound.
-     * @returns Either the {@link T | dependency} or `undefined` if {@link isOptional} is set to `true`.
+     * @param isOptional When set to `false` _(default)_ an exception will be thrown when the supplied {@link ProviderToken} isn't bound.
+     * @param asList Set to `true` if you need to retrieve _all_ the bound identifiers of the supplied {@link ProviderToken}. _(defaults to `false`)_
      */
-    get<T>(provider: ProviderToken<T>, isOptional?: boolean): T;
+    get<T, IsOptional extends boolean | undefined = undefined, AsList extends boolean | undefined = undefined>(provider: ProviderToken<T>, isOptional?: IsOptional, asList?: AsList): ProviderModuleGetReturn<T, IsOptional, AsList>;
     /**
-     * Can be used to retrieve many resolved `dependencies` from the module container at once.
+     * Can be used to retrieve many providers from the module container at once.
      *
      * @param deps Either one or more {@link ProviderToken}.
-     * @returns Tuple containing the {@link D | dependencies}.
+     * @returns Tuple containing the {@link D | providers}.
      *
-     * @example
      * ```ts
      * // When ProviderTokens are supplied, TS auto-inference works as expected.
      * // `car` will infer the `Car` type, `engine` the `Engine` type and `dashboard` the `Dashboard` type.
-     * const [car, engine, dashboard] = AppModule.getMany(
+     * const [car, engine, dashboard, wheels] = Module.getMany(
      *   Car,
      *   Engine,
-     *   { provider: Dashboard, isOptional: true }
+     *   { provider: Dashboard, isOptional: true },
+     *   { provider: Wheel, asList: true },
      * );
      *
      * // When auto-inference is not possible, you can manually cast the types.
-     * const [configService, userService] = AppModule.getMany<[typeof ConfigService, typeof UserService]>('CONFIG_SERVICE', UserService);
+     * const [configService, userService] = Module.getMany('CONFIG_SERVICE', UserService) as [ConfigService, UserService];
      * // Now the `configService` is of type `ConfigService` and the `userService` is of type `UserService`.
      * ```
      */
-    getMany<D extends (ProviderModuleGetManyParam<any> | ProviderToken)[]>(...deps: D | unknown[]): ProviderModuleGetManySignature<D>;
+    getMany<D extends (ProviderModuleGetManyParam<any> | ProviderToken | ProviderIdentifier)[]>(...deps: D): ProviderModuleGetManyReturn<D>;
     /**
-     * Can be used to _lazily_ import one or more {@link IProviderModule | modules} into _this_ module.
+     * Can be used to check if _this_ {@link IProviderModule | Module} is `exporting` a specific {@link IProviderModule | Module}.
      *
-     * @param module The `module` to be imported.
+     * @param idOrModule Either the {@link ModuleIdentifier} or the {@link IProviderModule} itself.
      */
-    lazyImport(...module: ProviderModuleOrDefinition[]): void;
+    isExportingModule(idOrModule: ModuleIdentifier | IProviderModule): boolean;
     /**
-     * Casts the current module type to the {@link IProviderModuleNaked} type.
+     * Can be used to check if _this_ {@link IProviderModule | Module} is `exporting` a specific {@link DependencyProvider | Provider}.
      *
-     * **Internally used and for testing purposes!**
+     * @param tokenOrIdentifier Either the {@link ProviderToken} or the {@link ProviderIdentifier} itself.
      */
-    toNaked(): IProviderModuleNaked;
+    isExportingProvider(tokenOrIdentifier: ProviderToken | ProviderIdentifier): boolean;
     /**
-     * Removes all the bindings from the {@link IProviderModuleNaked.container | container}.
+     * Can be used to _completely_ reset a module.
      *
-     * **Note:** The module can be fully re-initialized by invoking the {@link _internalInit} method.
+     * It means that all bound providers will be removed from the `container` and
+     * all definitions cleared, leaving it as a pristine module ready to be
+     * updated with new definitions.
+     *
+     * **Note:** _This is not the same as the {@link dispose} method!_
+     */
+    reset(): Promise<void>;
+    /**
+     * It first invokes the {@link reset} method and then permanentely destroys the module's `container`.
+     *
+     * **Note:** _If other modules have imported `this` module, they'll not be able anymore to_
+     * _resolve dependencies from it which will cause errors to be thrown!_
+     * _Make sure to use {@link dispose} carefully as it is an irreversible action._
      */
     dispose(): Promise<void>;
-    /** Returns the {@link IProviderModule.identifier}. */
+    /** Returns the {@link IProviderModule.id}. */
     toString(): string;
 }
-type ModuleIdentifier = symbol | string;
-type ProviderModuleOrDefinition = IProviderModule | IProviderModuleDefinition;
-type ProviderModuleGetManySignature<Tokens extends (ProviderModuleGetManyParam<any> | ProviderToken)[]> = {
-    [K in keyof Tokens]: Tokens[K] extends ProviderModuleGetManyParam<infer U> ? U : Tokens[K] extends ProviderToken<infer T> ? T : Tokens[K] extends ProviderIdentifier<infer I> ? I : never;
+type ProviderModuleGetReturn<T, IsOptional extends boolean | undefined = undefined, AsList extends boolean | undefined = undefined> = AsList extends true ? IsOptional extends true ? (T | undefined)[] : T[] : IsOptional extends true ? T | undefined : T;
+type ProviderModuleGetManyReturn<Tokens extends (ProviderModuleGetManyParam<any> | ProviderToken | ProviderIdentifier)[]> = {
+    [K in keyof Tokens]: Tokens[K] extends ProviderModuleGetManyParam<infer U> ? ProviderModuleGetReturn<U, Tokens[K]['isOptional'], Tokens[K]['asList']> : Tokens[K] extends ProviderToken<infer T> ? T : Tokens[K] extends ProviderIdentifier<infer I> ? I : never;
 };
 type ProviderModuleGetManyParam<T> = {
     /** The {@link ProviderToken}. */
     provider: ProviderToken<T>;
     /** When set to `false` _(default)_ an exception will be thrown when the {@link ProviderModuleGetManyParam.provider | provider} isn't bound. */
     isOptional?: boolean;
+    /** Set to `true` if you need to retrieve _all_ the bound identifiers of the supplied {@link ProviderToken}. _(defaults to `false`)_ */
+    asList?: boolean;
 };
 
-interface IAppModule extends Except<IProviderModule, 'isGlobal'> {
-    readonly _strict: AppModuleOptions['_strict'];
-    /** Must be invoked _(only once during the application lifecycle)_ in order to provide the {@link options} to the module. */
-    register<AsNaked extends boolean = false>(options: AppModuleOptions): AsNaked extends false ? IAppModule : IAppModule & IProviderModuleNaked;
-    toNaked(): IAppModule & IProviderModuleNaked;
-}
-interface AppModuleOptions extends Except<InternalInitOptions, 'appModule' | 'isGlobal' | 'exports' | 'isDisposed'> {
+interface ProviderModuleOptions {
+    /**
+     * The module `ID`.
+     *
+     * **Note:** _It doesn't have to be unique, however, the `AppModule` id is a reserved id and it'll throw an error if used._
+     */
+    readonly id: ModuleIdentifier;
+    /** Import additional `modules` or `blueprints` into _this_ module. */
+    readonly imports?: ImportsDefinition;
+    /** The `providers` that will be instantiated by the container and that may be shared at least across _this_ module. */
+    readonly providers?: ProvidersDefinition;
+    /**
+     * The subset of `providers`, `modules` or `blueprints` that
+     * are provided by _this_ module and should be available in other modules which import _this_ module.
+     */
+    readonly exports?: ExportsDefinition;
     /**
-     * When set to `true` it'll enforce an opinionated set of rules
-     * which _can help_ in avoiding common pitfalls which may otherwise produce
-     * undesired side-effects or edge-case bugs.
+     * The default {@link InjectionScope} to be used when a {@link ProvidersDefinition | Provider} does not have a defined `scope`.
      *
-     * **Note:** _Do not open an `issue` if a bug or edge-case is caused by having the `strict` property disabled!_
+     * Defaults to {@link InjectionScope.Singleton}.
+     */
+    readonly defaultScope?: InjectionScope;
+    /**
+     * When a module is set to be `global`, it'll be automatically imported into the `AppModule`
+     * during its initialization.
      *
-     * - `markAsGlobal`: Will not be enforced anymore.
+     * **Note:** _Importing a `global` module into another module does nothing._
      *
-     * Defaults to `true`.
+     * Defaults to `false`.
      */
-    _strict?: boolean;
+    readonly isGlobal?: boolean;
+    /**
+     * Callback which will be invoked once the module container has been initialized
+     * and the providers resolved.
+     *
+     * @param module The instance of the {@link IProviderModule | module}.
+     */
+    readonly onReady?: (module: IProviderModule) => void | Promise<void>;
+    /**
+     * The provided callbacks will be invoked when the `reset` method is invoked.
+     *
+     * @returns See {@link OnCleanupOptions}.
+     */
+    readonly onReset?: () => OnCleanupOptions;
+    /**
+     * The provided callbacks will be invoked when the `dispose` method is invoked.
+     *
+     * @returns See {@link OnCleanupOptions}.
+     */
+    readonly onDispose?: () => OnCleanupOptions;
+}
+type OnCleanupOptions = RequireAtLeastOne<{
+    /**
+     * It'll be invoked _before_ the process starts.
+     *
+     * @param module The {@link IProviderModule | module} instance.
+     */
+    before: (module: IProviderModule) => void | Promise<void>;
+    /** It'll be invoked _after_ the process ended. */
+    after: () => void | Promise<void>;
+}>;
+
+interface ProviderModuleOptionsInternal extends ProviderModuleOptions {
+    /** Overwrite the internal reference to the `AppModule`. */
+    appModuleRef?: IProviderModule;
+    inversify?: {
+        /** Overwrite the `Inversify` parent container.  */
+        parentContainer?: Container;
+    };
+}
+
+declare class ProviderModule implements IProviderModule {
+    get id(): ModuleIdentifier;
+    get definition(): ModuleDefinition<true>;
+    get update(): IDynamicModuleDefinition;
+    get middlewares(): IMiddlewaresManager;
+    get isDisposed(): boolean;
+    get isAppModule(): boolean;
+    /**
+     * Holds a reference to the `AppModule`.
+     *
+     * Static property needed in order to avoid introducing a _cirular dependency_ between
+     * the `AppModule` instance and the `ProviderModule` class.
+     */
+    static readonly APP_MODULE_REF: IProviderModule;
+    readonly appModuleRef: ProviderModule;
+    readonly options: ProviderModuleOptions;
+    readonly middlewaresManager: MiddlewaresManager;
+    readonly dynamicModuleDef: DynamicModuleDefinition;
+    readonly moduleContainer: ModuleContainer;
+    readonly importedModuleContainers: Map<IProviderModule, ImportedModuleContainer>;
+    private disposed;
+    constructor({ appModuleRef: appModule, inversify, ...publicOptions }: ProviderModuleOptionsInternal);
+    static create(optionsOrBlueprint: ProviderModuleOptions | ProviderModuleBlueprint): IProviderModule;
+    static blueprint(moduleOptions: ProviderModuleOptions, blueprintOptions?: ModuleBlueprintOptions): ProviderModuleBlueprint;
+    isImportingModule(idOrModule: ModuleIdentifier | IProviderModule): boolean;
+    hasProvider<T>(provider: ProviderToken<T>): boolean;
+    get<T, IsOptional extends boolean | undefined = undefined, AsList extends boolean | undefined = undefined>(provider: ProviderToken<T>, isOptional?: IsOptional, asList?: AsList): ProviderModuleGetReturn<T, IsOptional, AsList>;
+    getMany<D extends (ProviderModuleGetManyParam<any> | ProviderToken)[]>(...deps: D | unknown[]): ProviderModuleGetManyReturn<D>;
+    isExportingModule(idOrModule: ModuleIdentifier | IProviderModule): boolean;
+    isExportingProvider(tokenOrIdentifier: ProviderToken | ProviderIdentifier): boolean;
+    reset(shouldInvokeCb?: boolean): Promise<void>;
+    dispose(): Promise<void>;
+    toString(): string;
+    private throwIfIdIsMissing;
+    private throwIfDisposed;
+}
+
+/**
+ * The `root` {@link IProviderModule} of your application.
+ *
+ * All global modules are imported into the {@link AppModule} and all your custom
+ * modules inherit from it.
+ */
+declare const AppModule: IProviderModule;
+
+type ModuleIdentifier = symbol | string;
+type ModuleOrBlueprint = (ProviderModule | IProviderModule) | ProviderModuleBlueprint;
+type ImportsDefinition = ModuleOrBlueprint[];
+type ProvidersDefinition = DependencyProvider[];
+type ExportsDefinition = ExportDefinition[];
+type ImportsDefinitionOptimized = Set<IProviderModule>;
+type ProvidersDefinitionOptimized = Set<DependencyProvider>;
+type ExportsDefinitionOptimized = Set<ExportDefinition>;
+interface ModuleDefinition<Optimized extends boolean = false> {
+    readonly imports: Optimized extends false ? ImportsDefinition : ImportsDefinitionOptimized;
+    readonly providers: Optimized extends false ? ProvidersDefinition : ProvidersDefinitionOptimized;
+    readonly exports: Optimized extends false ? ExportsDefinition : ExportsDefinitionOptimized;
 }
+type ExportDefinition = ProviderToken | ModuleOrBlueprint;
 
 /** See {@link https://inversify.io/docs/api/decorator/#inject} for more details. */
 declare function Inject(provider: ProviderToken): MethodDecorator & ParameterDecorator & PropertyDecorator;
@@ -847,25 +734,31 @@ declare class InjectionError extends Error {
 /** Exception which indicates that there is a generic error with an instance of {@link IProviderModule}. */
 declare class InjectionProviderModuleError extends Error {
     name: string;
-    constructor(module: ProviderModuleOrDefinition, message: string);
+    constructor(module: IProviderModule, message: string);
+}
+
+/** Exception which indicates that an `unknown` type of {@link ProviderToken} has been supplied.  */
+declare class InjectionProviderModuleUnknownProviderError extends InjectionProviderModuleError {
+    name: string;
+    constructor(module: IProviderModule, providerToken: ProviderToken);
 }
 
 /** Exception which indicates an invokation of a disposed module.  */
 declare class InjectionProviderModuleDisposedError extends InjectionProviderModuleError {
     name: string;
-    constructor(module: ProviderModuleOrDefinition);
+    constructor(module: IProviderModule);
 }
 
 /** Exception which indicates that a module has been initialized without an `identifier`.  */
 declare class InjectionProviderModuleMissingIdentifierError extends InjectionProviderModuleError {
     name: string;
-    constructor(module: ProviderModuleOrDefinition);
+    constructor(module: IProviderModule);
 }
 
-/** Exception which indicates an error with regards to the `isGlobal` option.  */
-declare class InjectionProviderModuleGlobalMarkError extends InjectionProviderModuleError {
+/** Exception which indicates that a module container does not contain the requested provider.  */
+declare class InjectionProviderModuleMissingProviderError extends InjectionProviderModuleError {
     name: string;
-    constructor(module: ProviderModuleOrDefinition, message: string);
+    constructor(module: IProviderModule, providerToken: ProviderToken);
 }
 
 declare function injectionScopeToBindingScope(injectionScope: InjectionScope): BindingScope;
@@ -876,9 +769,11 @@ declare namespace ProviderTokenHelpers {
     function isValueToken<T>(provider: ProviderToken<T>): provider is ProviderValueToken<T>;
     function isFactoryToken<T>(provider: ProviderToken<T>): provider is ProviderFactoryToken<T>;
     function isProviderIdentifier<T = any>(value: any): value is ProviderIdentifier<T>;
-    function toServiceIdentifier<T = any>(provider: ProviderToken<T>): ServiceIdentifier<T>;
-    function toServiceIdentifiers(providers: ProviderToken[]): ServiceIdentifier<unknown>[];
-    function toDependencyProviderWithOptions<T extends DependencyProvider<any>>(original: T, override?: Partial<T>): T;
+    function toProviderIdentifier<T = any>(provider: ProviderToken<T>): ProviderIdentifier<T>;
+    function toProviderIdentifiers(providers: ProviderToken[]): ProviderIdentifier<unknown>[];
+    function providerIdentifierToString(providerIdentifier: ProviderIdentifier): string;
+    function providerTokenToString(providerToken: ProviderToken): string;
+    function providerTokensAreEqual(p0: ProviderToken, p1: ProviderToken): boolean;
     /**
      * The priority order is as follows:
      * 1. From the `ProviderToken.scope`
@@ -895,14 +790,11 @@ declare namespace ProviderTokenHelpers {
 }
 
 declare namespace ProviderModuleHelpers {
-    function buildInternalConstructorParams(params: Partial<ProviderModuleOptions & ProviderModuleOptionsInternal>): ProviderModuleOptions;
-    function getOptionsOrModuleDefinitionOptions(optionsOrDefinition: ProviderModuleOptions | IProviderModuleDefinition): {
-        options: ProviderModuleOptions;
-        internalOptions: ProviderModuleOptionsInternal;
-    };
-    function isModuleDefinition(value: any): value is IProviderModuleDefinition;
-    function isLazyExport(exp: any): exp is LazyExport;
-    function tryStaticOrLazyExportToStaticExport(module: IProviderModule, exp: StaticExport | LazyExport): StaticExport | void;
+    function isModule(value: any): value is IProviderModule;
+    function isBlueprint(value: any): value is ProviderModuleBlueprint;
+    function isModuleOrBlueprint(value: any): value is IProviderModule | ProviderModuleBlueprint;
+    function tryBlueprintToModule(value: IProviderModule | ProviderModuleBlueprint): IProviderModule;
+    function blueprintToModule(moduleBlueprint: ProviderModuleBlueprint): IProviderModule;
 }
 
 declare function isPlainObject(o: any): o is object;
@@ -913,4 +805,6 @@ declare function isFunction(v: any): boolean;
 
 declare function isClassOrFunction(value: any): value is Function | Class<any>;
 
-export { AppModule, type AppModuleOptions, type DependencyProvider, type ExportsList, GLOBAL_APP_MODULE_ID, GlobalAppModule, GlobalContainer, type IAppModule, type IProviderModule, type IProviderModuleDefinition, type IProviderModuleNaked, Inject, InjectFromBase, Injectable, InjectionError, InjectionProviderModuleDisposedError, InjectionProviderModuleError, InjectionProviderModuleGlobalMarkError, InjectionProviderModuleMissingIdentifierError, InjectionScope, type InternalInitOptions, MultiInject, Named, type OnEvent, Optional, type ProviderClassToken, type ProviderFactoryToken, type ProviderIdentifier, ProviderModule, ProviderModuleDefinition, type ProviderModuleGetManyParam, type ProviderModuleGetManySignature, ProviderModuleHelpers, type ProviderModuleOptions, type ProviderModuleOptionsInternal, type ProviderModuleOrDefinition, type ProviderOptions, type ProviderScopeOption, type ProviderToken, ProviderTokenHelpers, type ProviderValueToken, Tagged, Unmanaged, bindingScopeToInjectionScope, injectionScopeToBindingScope, isClass, isClassOrFunction, isFunction, isPlainObject };
+declare function deepClone<T>(obj: T): T;
+
+export { AppModule, DefinitionEventType, type DependencyProvider, type ExportDefinition, type ExportsDefinition, type ExportsDefinitionOptimized, IProviderModule, Inject, InjectFromBase, Injectable, InjectionError, InjectionProviderModuleDisposedError, InjectionProviderModuleError, InjectionProviderModuleMissingIdentifierError, InjectionProviderModuleMissingProviderError, InjectionProviderModuleUnknownProviderError, InjectionScope, MiddlewareType, MultiInject, Named, Optional, type ProviderClassToken, type ProviderFactoryToken, type ProviderIdentifier, ProviderModule, ProviderModuleBlueprint, type ProviderModuleGetManyParam, type ProviderModuleGetManyReturn, type ProviderModuleGetReturn, ProviderModuleHelpers, type ProviderModuleOptions, type ProviderModuleOptionsInternal, type ProviderOptions, type ProviderScopeOption, type ProviderToken, ProviderTokenHelpers, type ProviderValueToken, Tagged, Unmanaged, bindingScopeToInjectionScope, deepClone, injectionScopeToBindingScope, isClass, isClassOrFunction, isFunction, isPlainObject };