@adimm/x-injection 0.3.1

package/dist/index.d.cts

@@ -0,0 +1,831 @@
+import { BindingActivation, BindingDeactivation, BindingConstraints, Container, BindingScope, BindToFluentSyntax, GetOptions, IsBoundOptions, injectFromBase, MetadataName, MetadataTag, ServiceIdentifier } from 'inversify';
+import { Class, Except } from 'type-fest';
+
+/** The identifier of the `GlobalAppModule`. */
+declare const GLOBAL_APP_MODULE_ID = "GlobalAppModule";
+/** The default {@link IProviderModule.identifier}. */
+declare const ANONYMOUSE_MODULE_DEFAULT_ID = "AnonymousModule";
+
+declare enum InjectionScope {
+    /** When the service is resolved, the same cached resolved value will be used. */
+    Singleton = 0,
+    /** When the service is resolved, a new resolved value will be used each time. */
+    Transient = 1,
+    /** When the service is resolved within the same container request, the same resolved value will be used. */
+    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>;
+    /**
+     * 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> | 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.
+     *
+     * @example
+     * ```ts
+     * const connectionProvider = {
+     *   provide: 'CONNECTION',
+     *   useFactory: (optionsService: OptionsService, secondService: SecondService) => {
+     *     const options = optionsService.get();
+     *
+     *     return new DatabaseConnection(options);
+     *   },
+     *   // `inject` is optional.
+     *   inject: [OptionsService, SecondService]
+     * };
+     * ```
+     */
+    useFactory: (...providers: any[]) => T;
+    /**
+     * Optional list of providers to be injected into the context of the Factory `function`.
+     *
+     * 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.
+     *
+     * See {@link https://inversify.io/docs/fundamentals/lifecycle/activation/ | Activation}
+     * and {@link https://inversify.io/docs/fundamentals/lifecycle/deactivation/ | Deactivation} lifecycle.
+     */
+    onEvent?: OnEvent<T>;
+    /**
+     * Specifies whether the binding is used to provide a resolved value for the given {@link ProviderToken | provider}.
+     *
+     * See {@link https://inversify.io/docs/api/binding-syntax/#bindwhenfluentsyntax} for more details.
+     */
+    when?: (metadata: BindingConstraints) => boolean;
+}
+interface ProviderScopeOption {
+    /**
+     * 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 https://inversify.io/docs/fundamentals/binding/#scope} for more details..
+     */
+    scope?: InjectionScope;
+}
+
+/**
+ * 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;
+    /** The parent {@link IProviderModule | ProviderModule} of `this` instance. */
+    readonly module: IProviderModule;
+    readonly moduleNaked: IProviderModuleNaked;
+    constructor(module: IProviderModule);
+    /**
+     * 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: ProviderToken<T>, defaultScope: InjectionScope): boolean;
+    /** Low-level method which does exactly what {@link bindToContainer} does, however accepts a list of {@link providers}.  */
+    bindManyToContainer(providers: ProviderToken[], defaultScope: InjectionScope): void;
+    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;
+}
+
+/** 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;
+    /** The low-level `InversifyJS` {@link https://inversify.io/docs/api/container/ | container} instance. */
+    readonly container: Container;
+    /** Instance of the {@link ProviderModuleUtils}. */
+    readonly moduleUtils: ProviderModuleUtils;
+    /** 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;
+    };
+    /** The module dynamic exports method. */
+    readonly dynamicExports: DynamicExports | undefined;
+    /** 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'];
+    /** It'll _completely_ re-init the `module` with the provided {@link LazyInitOptions | options}. */
+    _lazyInit(options: LazyInitOptions): void;
+    /** Can be used to get the list of all the imported modules of this module. */
+    _getImportedModules(): IProviderModuleNaked[];
+    /** Can be used to get the list of all the providers of this module. */
+    _getProviders(): ProviderToken[];
+    /** Can be used to get the list of all the exportable modules and providers of this module. */
+    _getExportableModulesAndProviders(): StaticExports;
+    /**
+     * 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}.
+     *
+     * **Note:** _This is not the same as the {@link onActivationEvent}!_
+     *
+     * @param provider The {@link ProviderToken}.
+     * @param cb The `callback` to be invoked.
+     */
+    _onBind<T>(provider: ProviderToken<T>, cb: () => Promise<void> | void): void;
+    /**
+     * 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}.
+     *
+     * @param provider The {@link ProviderToken}.
+     * @param cb The `callback` to be invoked.
+     */
+    _onRebind<T>(provider: ProviderToken<T>, cb: () => Promise<void> | void): void;
+    /**
+     * Can be used to execute the provided {@link cb | callback} whenever a {@link provider} is `unbound`.
+     *
+     * **Note:** _This is not the same as the {@link onDeactivationEvent}!_
+     * _Also the {@link _onBind}, {@link __rebind} and {@link _onUnbind} registered callbacks will be removed._
+     *
+     * @param provider The {@link ProviderToken}.
+     * @param cb The `callback` to be invoked.
+     */
+    _onUnbind<T>(provider: ProviderToken<T>, cb: () => Promise<void> | void): void;
+    /**
+     * Internal method which can be used to completely overwrite the module {@link container}
+     * with the one provided.
+     *
+     * @param cb Callback which when invoked must return an instance of the {@link Container}.
+     */
+    _overwriteContainer(cb: () => Container): void;
+    /**
+     * Removes all the bindings from the {@link IProviderModuleNaked.container | container}.
+     *
+     * Then also sets to `null` these properties:
+     * - `container`
+     * - `imports`
+     * - `providers`
+     * - `exports`
+     * - `dynamicExports`
+     *
+     * **Note:** The module can be fully re-initialized by invoking the {@link _lazyInit} method.
+     */
+    _dispose(): Promise<void>;
+    /**
+     * Binds a {@link ProviderToken | provider}.
+     *
+     * See {@link https://inversify.io/docs/api/container/#bind | Container.bind} for more details.
+     */
+    __bind<T>(provider: ProviderToken<T>): BindToFluentSyntax<T>;
+    /**
+     * 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.
+     *
+     * @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`.
+     *
+     * 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.
+     *
+     * @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`.
+     *
+     * 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}.
+     *
+     * 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.
+     *
+     * 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.
+     *
+     * See {@link https://inversify.io/docs/api/container/#snapshot | Container.snapshot} for more details.
+     */
+    __takeSnapshot(): void;
+    /**
+     * Restore container state to last snapshot.
+     *
+     * 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.
+     *
+     * @param provider The {@link ProviderToken}.
+     * @returns A {@link BindToFluentSyntax | binding builder} to continue configuring the new binding.
+     *
+     * 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.
+     *
+     * 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.
+     *
+     * This will result in the {@link https://inversify.io/docs/fundamentals/lifecycle/deactivation/ | deactivation process}.
+     *
+     * See {@link https://inversify.io/docs/api/container/#unbind | Container.unbind} for more details.
+     */
+    __unbind(provider: ProviderToken): Promise<void>;
+    /**
+     * 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.
+     *
+     * 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.
+     */
+    __unbindSync(provider: ProviderToken): void;
+    /**
+     * Remove all bindings bound in this container.
+     *
+     * This will result in the {@link https://inversify.io/docs/fundamentals/lifecycle/deactivation/ | deactivation process}.
+     *
+     * See {@link https://inversify.io/docs/api/container/#unbindall | Container.unbindAll} for more details.
+     */
+    __unbindAll(): Promise<void>;
+}
+type LazyInitOptions = Except<ProviderModuleOptions & ProviderModuleOptionsInternal, 'identifier' | 'isAppModule'>;
+
+interface IProviderModule {
+    /** The module unique ID. */
+    readonly identifier: symbol;
+    /**
+     * Can be used to retrieve a resolved `dependency` from the module container.
+     *
+     * @param providerOrIdentifier Either the {@link ProviderToken} or the {@link ProviderIdentifier}.
+     * @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`.
+     */
+    get<T>(providerOrIdentifier: ProviderToken<T>, isOptional?: boolean): T;
+    /**
+     * Can be used to retrieve many resolved `dependencies` from the module container at once.
+     *
+     * @param deps Either one or more {@link ProviderToken} or {@link ProviderIdentifier}.
+     * @returns Tuple containing the {@link D | dependencies}.
+     *
+     * @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(
+     *   Car,
+     *   Engine,
+     *   { providerOrIdentifier: Dashboard, isOptional: 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);
+     * // 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>;
+    /**
+     * Adds an activation handler for the {@link provider}.
+     *
+     * See {@link https://inversify.io/docs/api/container/#onactivation} for more details.
+     */
+    onActivationEvent<T>(provider: ProviderToken<T>, cb: BindingActivation<T>): void;
+    /**
+     * Adds a deactivation handler for the {@link provider}.
+     *
+     * See {@link https://inversify.io/docs/api/container/#ondeactivation} for more details.
+     */
+    onDeactivationEvent<T>(provider: ProviderToken<T>, cb: BindingDeactivation<T>): void;
+    /**
+     * Casts the current module type to the {@link IProviderModuleNaked} type.
+     *
+     * **Internally used and for testing purposes!**
+     */
+    toNaked(): IProviderModuleNaked;
+    /** Returns the {@link IProviderModule.identifier} `symbol` description. */
+    toString(): string;
+}
+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 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;
+};
+
+interface ProviderModuleOptions {
+    /** The module unique ID. */
+    identifier?: symbol;
+    /** The list of imported {@link IProviderModule | modules} that export the {@link Provider | providers} which are required in this module. */
+    imports?: IProviderModule[];
+    /** The {@link ProviderToken | providers} that will be instantiated by the container and that may be shared at least across this module. */
+    providers?: ProviderToken[];
+    /**
+     * 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.
+     *
+     * _Check also the {@link dynamicExports} property._
+     */
+    exports?: StaticExports;
+    /**
+     * When provided, can be used to control which providers from the {@link ProviderModuleOptions.exports | exports}
+     * array should actually be exported into the importing module.
+     *
+     * **Note:** _Static {@link ProviderModuleOptions.exports | exports} should always be preferred as their static nature implies predictibility._
+     * _This is for advanced use cases only, and most probably you may never need to use a dynamic export!_
+     *
+     * To keep in mind in order to avoid nasty bugs:
+     * - You **must always** return only the providers/modules declared into the static {@link ProviderModuleOptions.exports | exports} array.
+     * - You **can** return _less_ providers/modules as long as they are still part of the static {@link ProviderModuleOptions.exports | exports} array.
+     * - You **cannot** return _more_ providers/modules than the static {@link ProviderModuleOptions.exports | exports} array!
+     *
+     * @example
+     * ```ts
+     * {
+     *   exports: [ConfigModule, UserModule, PaymentService, ReviewService],
+     *   dynamicExports: (importerModule, moduleExports) => {
+     *     const shouldExportOnlyTheServices = true;
+     *
+     *     if (shouldExportOnlyTheServices === false) return moduleExports;
+     *
+     *     return moduleExports.flatMap((ex) => {
+     *       // With `flatMap` we can map and filter out elements
+     *       // from the sequence at the same time
+     *       // by returning an empty array.
+     *       return ex instanceof ProviderModule ? [] : ex;
+     *     });
+     *   }
+     * }
+     *
+     * // Or
+     *
+     * {
+     *   exports: [ConfigModule, UserModule, PaymentService, ReviewService],
+     *   dynamicExports: (importerModule, moduleExports) => {
+     *     // We export all the providers only when the importer module is not the `BULLIED_MODULE`.
+     *     if (importerModule.toNaked().name !== 'BULLIED_MODULE') return moduleExports;
+     *
+     *     return [ConfigModule];
+     *   }
+     * }
+     *
+     * ```
+     */
+    dynamicExports?: DynamicExports;
+    /**
+     * The default {@link InjectionScope} to be used when a {@link ProviderToken} does not have a defined `scope`.
+     *
+     * Defaults to {@link InjectionScope.Singleton}.
+     */
+    defaultScope?: InjectionScope;
+    /**
+     * 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!**
+     *
+     * @param module The instance of the {@link IProviderModule | module}.
+     */
+    onReady?: (module: IProviderModule) => Promise<void>;
+    /**
+     * Callback which will be invoked whenever the internal module dispose method is invoked.
+     *
+     * **The method will be invoked right _before_ the clean-up process.**
+     *
+     * @param module The instance of the {@link IProviderModule | module}.
+     */
+    onDispose?: (module: IProviderModule) => Promise<void>;
+}
+interface ProviderModuleOptionsInternal {
+    isAppModule?: boolean;
+    /** Can be used to manually provide a {@link Container} instance. */
+    container?: () => Container;
+}
+type StaticExports = (ProviderToken | IProviderModule)[];
+type DynamicExports = (
+/** The {@link IProviderModule} which is importing this module. */
+importerModule: IProviderModule, 
+/** The {@link ProviderModuleOptions.exports | exports} array of this module. */
+moduleExports: StaticExports) => StaticExports;
+
+interface IAppModule extends IProviderModule {
+    /** 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;
+}
+type AppModuleOptions = Except<LazyInitOptions, 'exports' | 'dynamicExports'>;
+
+/** See {@link https://inversify.io/docs/api/decorator/#inject} for more details. */
+declare function Inject(provider: ProviderToken): MethodDecorator & ParameterDecorator & PropertyDecorator;
+
+/** See {@link https://inversify.io/docs/api/decorator/#multiinject} for more details. */
+declare function MultiInject(provider: ProviderToken): MethodDecorator & ParameterDecorator & PropertyDecorator;
+
+/** See {@link https://inversify.io/docs/api/decorator/#injectfrombase} for more details. */
+declare function InjectFromBase(options?: Parameters<typeof injectFromBase>[0]): ClassDecorator;
+
+/** See {@link https://inversify.io/docs/api/decorator/#named} for more details. */
+declare function Named(name: MetadataName): MethodDecorator & ParameterDecorator & PropertyDecorator;
+
+/** See {@link https://inversify.io/docs/api/decorator/#optional} for more details. */
+declare function Optional(): MethodDecorator & ParameterDecorator & PropertyDecorator;
+
+/** See {@link https://inversify.io/docs/api/decorator/#postconstruct} for more details. */
+declare function PostConstruct(): MethodDecorator;
+
+/** See {@link https://inversify.io/docs/api/decorator/#predestroy} for more details. */
+declare function PreDestroy(): MethodDecorator;
+
+/** See {@link https://inversify.io/docs/api/decorator/#tagged} for more details. */
+declare function Tagged(key: MetadataTag, value: unknown): MethodDecorator & ParameterDecorator & PropertyDecorator;
+
+/** See {@link https://inversify.io/docs/api/decorator/#unmanaged} for more details. */
+declare function Unmanaged(): MethodDecorator & ParameterDecorator & PropertyDecorator;
+
+/** Exception which indicates that there is a generic error. */
+declare class XInjectionError extends Error {
+    name: string;
+}
+
+/** Exception which indicates that there is a generic error with an instance of {@link IProviderModule}. */
+declare class XInjectionProviderModuleError extends Error {
+    name: string;
+    constructor(module: IProviderModule, message: string);
+}
+
+declare class XInjectionProviderModuleDisposedError extends XInjectionProviderModuleError {
+    name: string;
+    constructor(module: IProviderModule);
+}
+
+/**
+ * Exception which indicates that an instance of {@link IProviderModule}
+ * imports another module which dynamically exports its providers/modules and
+ * is trying to dynamically export more or different providers/modules than the
+ * ones declared into its static exports.
+ */
+declare class XInjectionDynamicExportsOutOfRange extends XInjectionProviderModuleError {
+    name: string;
+    constructor(module: IProviderModule);
+}
+
+/**
+ * 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}_.
+ *
+ * @example
+ * ```ts
+ * import { ProviderModule } from '@adimm/x-injection';
+ *
+ * const EngineModule = new ProviderModule({
+ *   providers: [EngineService],
+ *   exports: [EngineService]
+ * });
+ *
+ * const DashboardModule = new ProviderModule({
+ *   providers: [DashboardService],
+ *   exports: [DashboardService]
+ * });
+ *
+ * const CarModule = new ProviderModule({
+ *   imports: [EngineModule, DashboardModule],
+ *   providers: [CarService],
+ *   exports: [CarService]
+ * });
+ *
+ * // Run-time class replacement:
+ * const RedCarModule = new ProviderModule({
+ *   imports: [CarModule],
+ *   providers: [
+ *     {
+ *       provide: CarService,
+ *       useClass: RedCarService,
+ *     }
+ *   ],
+ * });
+ *
+ * // Run-time factory example:
+ * const BlackCarModule = new ProviderModule({
+ *   imports: [CarModule],
+ *   providers: [
+ *     {
+ *       provide: CarService,
+ *       useFactory: (carService: CarService) => {
+ *         carService.setColor('black');
+ *
+ *         return carService;
+ *       },
+ *       inject: [CarService]
+ *     }
+ *   ],
+ * });
+ * ```
+ */
+declare class ProviderModule implements IProviderModule {
+    readonly identifier: symbol;
+    protected readonly isAppModule: boolean;
+    protected readonly container: Container;
+    protected readonly defaultScope: IProviderModuleNaked['defaultScope'];
+    protected readonly dynamicExports: IProviderModuleNaked['dynamicExports'];
+    protected readonly onReady: IProviderModuleNaked['onReady'];
+    protected readonly onDispose: IProviderModuleNaked['onDispose'];
+    protected readonly moduleUtils: IProviderModuleNaked['moduleUtils'];
+    private readonly providers;
+    private readonly exports;
+    private readonly imports;
+    private readonly registeredBindingSideEffects;
+    constructor({ identifier, imports, providers, exports, defaultScope, dynamicExports, onReady, onDispose, ..._internalParams }: ProviderModuleOptions);
+    get<T>(provider: ProviderToken<T>, isOptional?: boolean): T;
+    getMany<D extends (ProviderModuleGetManyParam<any> | ProviderToken)[]>(...deps: D | unknown[]): ProviderModuleGetManySignature<D>;
+    onActivationEvent<T>(provider: ProviderToken<T>, cb: BindingActivation<T>): void;
+    onDeactivationEvent<T>(provider: ProviderToken<T>, cb: BindingDeactivation<T>): void;
+    toNaked(): IProviderModuleNaked;
+    toString(): string;
+    private prepareContainer;
+    private injectImportedModules;
+    private injectProviders;
+    private registerBindingSideEffect;
+    private invokeRegisteredBindingSideEffects;
+    private removeRegisteredBindingSideEffects;
+    private shouldThrowWhenModuleDynamicExportsDontMatchTheStaticExports;
+    private shouldThrowIfDisposed;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked._dispose}.
+     */
+    protected _dispose(): Promise<void>;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked._lazyInit}.
+     */
+    protected _lazyInit({ imports, providers, exports, defaultScope, dynamicExports, onReady, onDispose, ..._internalParams }: LazyInitOptions): void;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked._getImportedModules}.
+     */
+    protected _getImportedModules(): IProviderModuleNaked[];
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked._getProviders}.
+     */
+    protected _getProviders(): ProviderToken[];
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked._getExportableModulesAndProviders}.
+     */
+    protected _getExportableModulesAndProviders(): StaticExports;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked._onBind}.
+     */
+    protected _onBind<T>(provider: ProviderToken<T>, cb: () => Promise<void> | void): void;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked._onRebind}.
+     */
+    protected _onRebind<T>(provider: ProviderToken<T>, cb: () => Promise<void> | void): void;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked._onUnbind}.
+     */
+    protected _onUnbind<T>(provider: ProviderToken<T>, cb: () => Promise<void> | void): void;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked._overwriteContainer}.
+     */
+    protected _overwriteContainer(cb: () => Container): void;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked.__bind}.
+     */
+    protected __bind<T>(provider: ProviderToken<T>): BindToFluentSyntax<T>;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked.__get}.
+     */
+    protected __get<T>(provider: ProviderToken<T>, options?: GetOptions): T;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked.__getAsync}.
+     */
+    protected __getAsync<T>(provider: ProviderToken<T>, options?: GetOptions): Promise<T>;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked.__getAll}.
+     */
+    protected __getAll<T>(provider: ProviderToken<T>, options?: GetOptions): T[];
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked.__getAllAsync}.
+     */
+    protected __getAllAsync<T>(provider: ProviderToken<T>, options?: GetOptions): Promise<T[]>;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked.__isBound}.
+     */
+    protected __isBound(provider: ProviderToken, options?: IsBoundOptions): boolean;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked.__isCurrentBound}.
+     */
+    protected __isCurrentBound(provider: ProviderToken, options?: IsBoundOptions): boolean;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked.__takeSnapshot}.
+     */
+    protected __takeSnapshot(): void;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked.__restoreSnapshot}.
+     */
+    protected __restoreSnapshot(): void;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked.__rebind}.
+     */
+    protected __rebind<T>(provider: ProviderToken<T>): Promise<BindToFluentSyntax<T>>;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked.__rebindSync}.
+     */
+    protected __rebindSync<T>(provider: ProviderToken<T>): BindToFluentSyntax<T>;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked.__unbind}.
+     */
+    protected __unbind(provider: ProviderToken): Promise<void>;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked.__unbindSync}.
+     */
+    protected __unbindSync(provider: ProviderToken): void;
+    /**
+     * **Publicly visible when the instance is casted to {@link IProviderModuleNaked}.**
+     *
+     * See {@link IProviderModuleNaked.__unbindAll}.
+     */
+    protected __unbindAll(): Promise<void>;
+}
+
+/**
+ * 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 {
+    private nakedModule;
+    private isLoaded;
+    constructor();
+    register<AsNaked extends boolean = false>(options: AppModuleOptions): AsNaked extends false ? IAppModule : IAppModule & IProviderModuleNaked;
+    toNaked(): IAppModule & IProviderModuleNaked;
+    protected _dispose(): Promise<void>;
+}
+/**
+ * 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
+ * import { AppModule } from '@adimm/x-injection';
+ *
+ * // 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;
+
+declare function injectionScopeToBindingScope(injectionScope: InjectionScope): BindingScope;
+
+declare namespace ProviderTokenHelpers {
+    function isClassToken<T>(provider: ProviderToken<T>): provider is ProviderClassToken<T>;
+    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>[];
+    /**
+     * The priority order is as follows:
+     * 1. From the `ProviderToken.scope`
+     * 2. From the class `@Injectable(scope)` decorator
+     * 3. From the `ProviderModule` default scope.
+     *
+     * @param provider The {@link ProviderToken}.
+     * @param moduleDefaultScope The module default scope.
+     */
+    function getInjectionScopeByPriority(provider: ProviderToken, moduleDefaultScope: InjectionScope): InjectionScope;
+    function tryGetProviderOptions<T>(provider: ProviderToken<T>): (ProviderOptions<T> & ProviderScopeOption) | undefined;
+    function tryGetScopeFromProvider(provider: ProviderToken): InjectionScope | undefined;
+    function tryGetDecoratorScopeFromClass<T = any>(provider: ProviderToken<T>): InjectionScope | undefined;
+}
+
+declare namespace ProviderModuleHelpers {
+    function buildInternalConstructorParams(params: ProviderModuleOptions & ProviderModuleOptionsInternal): ProviderModuleOptions;
+    function isDynamicExport(exporter: StaticExports | DynamicExports): exporter is DynamicExports;
+}
+
+export { ANONYMOUSE_MODULE_DEFAULT_ID, AppModule, type AppModuleOptions, type DynamicExports, GLOBAL_APP_MODULE_ID, GlobalAppModule, GlobalContainer, type IAppModule, type IProviderModule, type IProviderModuleNaked, Inject, InjectFromBase, Injectable, InjectionScope, type LazyInitOptions, MultiInject, Named, type OnEvent, Optional, PostConstruct, PreDestroy, type ProviderClassToken, type ProviderFactoryToken, type ProviderIdentifier, ProviderModule, type ProviderModuleGetManyParam, type ProviderModuleGetManySignature, ProviderModuleHelpers, type ProviderModuleOptions, type ProviderModuleOptionsInternal, type ProviderOptions, type ProviderScopeOption, type ProviderToken, ProviderTokenHelpers, type ProviderValueToken, type StaticExports, Tagged, Unmanaged, XInjectionDynamicExportsOutOfRange, XInjectionError, XInjectionProviderModuleDisposedError, XInjectionProviderModuleError, injectionScopeToBindingScope };