@lppedd/di-wise-neo 0.3.0

package/dist/es/index.d.mts

@@ -0,0 +1,772 @@
+/**
+ * Constructor type.
+ */
+interface Constructor<Instance extends object> {
+    new (...args: any[]): Instance;
+    readonly name: string;
+    readonly length: number;
+}
+/**
+ * Token type.
+ */
+type Token<Value = any> = [Value] extends [object] ? Type<Value> | Constructor<Value> : Type<Value>;
+/**
+ * Describes a {@link Token} array with at least one element.
+ */
+type Tokens<Value = any> = [Token<Value>, ...Token<Value>[]];
+/**
+ * Type API.
+ */
+interface Type<A> {
+    /**
+     * Name of the type.
+     */
+    readonly name: string;
+    /**
+     * Create an intersection type from another type.
+     *
+     * @example
+     * ```ts
+     * const A = Type<A>("A");
+     * const B = Type<B>("B");
+     *
+     * A.inter("I", B); // => Type<A & B>
+     * ```
+     */
+    inter<B>(typeName: string, B: Type<B>): Type<A & B>;
+    /**
+     * Create a union type from another type.
+     *
+     * @example
+     * ```ts
+     * const A = Type<A>("A");
+     * const B = Type<B>("B");
+     *
+     * A.union("U", B); // => Type<A | B>
+     * ```
+     */
+    union<B>(typeName: string, B: Type<B>): Type<A | B>;
+}
+/**
+ * Create a type token.
+ *
+ * @example
+ * ```ts
+ * const Spell = Type<Spell>("Spell");
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function Type<T>(typeName: string): Type<T>;
+
+/**
+ * Provides a class instance for a token via a class constructor.
+ */
+interface ClassProvider<Instance extends object> {
+    readonly useClass: Constructor<Instance>;
+}
+/**
+ * Provides a value for a token via another existing token.
+ */
+interface ExistingProvider<Value> {
+    readonly useExisting: Token<Value>;
+}
+/**
+ * Provides a value for a token via a factory function.
+ *
+ * The factory function runs inside the injection context
+ * and can thus access dependencies via {@link inject}.
+ */
+interface FactoryProvider<Value> {
+    readonly useFactory: (...args: []) => Value;
+}
+/**
+ * Provides a direct - already constructed - value for a token.
+ */
+interface ValueProvider<T> {
+    readonly useValue: T;
+}
+/**
+ * A token provider.
+ */
+type Provider<Value = any> = ClassProvider<Value & object> | ExistingProvider<Value> | FactoryProvider<Value> | ValueProvider<Value>;
+
+declare const Scope: {
+    readonly Inherited: "Inherited";
+    readonly Transient: "Transient";
+    readonly Resolution: "Resolution";
+    readonly Container: "Container";
+};
+type Scope = (typeof Scope)[keyof typeof Scope];
+
+/**
+ * Token registration options.
+ */
+interface RegistrationOptions {
+    /**
+     * The scope of the registration.
+     */
+    readonly scope?: Scope;
+}
+/**
+ * Create a one-off type token from a factory function.
+ *
+ * @example
+ * ```ts
+ * class Wizard {
+ *   wand = inject(
+ *     Build(() => {
+ *       const wand = inject(Wand);
+ *       wand.owner = this;
+ *       // ...
+ *       return wand;
+ *     }),
+ *   );
+ * }
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function Build<Value>(factory: (...args: []) => Value): Type<Value>;
+
+/**
+ * Container creation options.
+ */
+interface ContainerOptions {
+    /**
+     * Whether to automatically register an unregistered class when resolving it as a token.
+     *
+     * @defaultValue false
+     */
+    readonly autoRegister: boolean;
+    /**
+     * The default scope for registrations.
+     *
+     * @defaultValue Scope.Inherited
+     */
+    readonly defaultScope: Scope;
+}
+/**
+ * Container API.
+ */
+interface Container {
+    /**
+     * The options used to create this container.
+     */
+    readonly options: ContainerOptions;
+    /**
+     * The parent container, or `undefined` if this is the root container.
+     */
+    readonly parent: Container | undefined;
+    /**
+     * Whether this container is disposed.
+     */
+    readonly isDisposed: boolean;
+    /**
+     * Creates a new child container that inherits this container's options.
+     *
+     * You can pass specific options to override the inherited ones.
+     */
+    createChild(options?: Partial<ContainerOptions>): Container;
+    /**
+     * Clears and returns all distinct cached values from this container's internal registry.
+     * Values from {@link ValueProvider} registrations are not included, as they are never cached.
+     *
+     * Note that only this container is affected. Parent containers, if any, remain unchanged.
+     */
+    clearCache(): unknown[];
+    /**
+     * Returns the cached value from the most recent registration of the token,
+     * or `undefined` if no value has been cached yet (the token has not been resolved yet).
+     *
+     * If the token has at least one registration in this container,
+     * the cached value is taken from the most recent of those registrations.
+     * Otherwise, it may be retrieved from parent containers, if any.
+     *
+     * Values are never cached for tokens with _transient_ or _resolution_ scope,
+     * or for {@link ValueProvider} registrations.
+     */
+    getCached<Value>(token: Token<Value>): Value | undefined;
+    /**
+     * Returns all cached values associated with registrations of the token,
+     * in the order they were registered, or an empty array if none have been cached.
+     *
+     * If the token has at least one registration in the current container,
+     * cached values are taken from those registrations.
+     * Otherwise, cached values may be retrieved from parent containers, if any.
+     *
+     * Values are never cached for tokens with _transient_ or _resolution_ scope,
+     * or for {@link ValueProvider} registrations.
+     */
+    getAllCached<Value>(token: Token<Value>): Value[];
+    /**
+     * Removes all registrations from this container's internal registry.
+     *
+     * Returns an array of distinct cached values that were stored within the removed registrations.
+     * Values from {@link ValueProvider} registrations are not included, as they are not cached.
+     *
+     * Note that only this container is affected. Parent containers, if any, remain unchanged.
+     */
+    resetRegistry(): unknown[];
+    /**
+     * Returns whether the token is registered in this container or in parent containers, if any.
+     */
+    isRegistered(token: Token): boolean;
+    /**
+     * Registers a {@link ClassProvider}, using the class itself as its token.
+     *
+     * Tokens provided to the {@link Injectable} decorator applied to the class
+     * are also registered as aliases. The scope is determined by the {@link Scoped}
+     * decorator, if present.
+     */
+    register<Instance extends object>(Class: Constructor<Instance>): this;
+    /**
+     * Registers a {@link ClassProvider} with a token.
+     */
+    register<Instance extends object, ProviderInstance extends Instance>(token: Token<Instance>, provider: ClassProvider<ProviderInstance>, options?: RegistrationOptions): this;
+    /**
+     * Registers a {@link FactoryProvider} with a token.
+     */
+    register<Value, ProviderValue extends Value>(token: Token<Value>, provider: FactoryProvider<ProviderValue>, options?: RegistrationOptions): this;
+    /**
+     * Registers an {@link ExistingProvider} with a token.
+     *
+     * The token will alias the one set in `useExisting`.
+     */
+    register<Value, ProviderValue extends Value>(token: Token<Value>, provider: ExistingProvider<ProviderValue>): this;
+    /**
+     * Registers a {@link ValueProvider} with a token.
+     *
+     * Values provided via `useValue` are never cached (scopes do not apply)
+     * and are simply returned as-is.
+     */
+    register<Value, ProviderValue extends Value>(token: Token<Value>, provider: ValueProvider<ProviderValue>): this;
+    /**
+     * Removes all registrations for the given token from the container's internal registry.
+     *
+     * Returns an array of distinct cached values that were stored within the removed registrations.
+     * Values from {@link ValueProvider} registrations are not included, as they are not cached.
+     *
+     * Note that only this container is affected. Parent containers, if any, remain unchanged.
+     */
+    unregister<Value>(token: Token<Value>): Value[];
+    /**
+     * Resolves the given class to the instance associated with it.
+     *
+     * If the class is registered in this container or any of its parent containers,
+     * an instance is created using the most recent registration.
+     *
+     * If the class is not registered, but it is decorated with {@link AutoRegister},
+     * or {@link ContainerOptions.autoRegister} is true, the class is registered automatically.
+     * Otherwise, resolution fails.
+     * The scope for the automatic registration is determined by either
+     * the {@link Scoped} decorator on the class, or {@link ContainerOptions.defaultScope}.
+     *
+     * If `optional` is false or is not passed and the class is not registered in the container
+     * (and could not be auto-registered), an error is thrown.
+     * Otherwise, if `optional` is true, `undefined` is returned.
+     *
+     * The resolution behavior depends on the {@link Provider} used during registration:
+     * - For {@link ValueProvider}, the explicitly provided instance is returned.
+     * - For {@link FactoryProvider}, the factory function is invoked to create the instance.
+     * - For {@link ClassProvider}, a new instance of the class is created according to its scope.
+     * - For {@link ExistingProvider}, the instance is resolved by referring to another registered token.
+     *
+     * If the class is registered with _container_ scope, the resolved instance is cached
+     * in the container's internal registry.
+     */
+    resolve<Instance extends object>(Class: Constructor<Instance>, optional?: false): Instance;
+    resolve<Instance extends object>(Class: Constructor<Instance>, optional: true): Instance | undefined;
+    resolve<Instance extends object>(Class: Constructor<Instance>, optional: boolean): Instance | undefined;
+    /**
+     * Resolves the given token to the value associated with it.
+     *
+     * If the token is registered in this container or any of its parent containers,
+     * its value is resolved using the most recent registration.
+     *
+     * If `optional` is false or not passed and the token is not registered in the container,
+     * an error is thrown. Otherwise, if `optional` is true, `undefined` is returned.
+     *
+     * The resolution behavior depends on the {@link Provider} used during registration:
+     * - For {@link ValueProvider}, the explicitly provided value is returned.
+     * - For {@link FactoryProvider}, the factory function is invoked to create the value.
+     * - For {@link ClassProvider}, a new instance of the class is created according to its scope.
+     * - For {@link ExistingProvider}, the value is resolved by referring to another registered token.
+     *
+     * If the token is registered with _container_ scope, the resolved value is cached
+     * in the container's internal registry.
+     */
+    resolve<Value>(token: Token<Value>, optional?: false): Value;
+    resolve<Value>(token: Token<Value>, optional: true): Value | undefined;
+    resolve<Value>(token: Token<Value>, optional: boolean): Value | undefined;
+    /**
+     * Resolves the given class to all instances provided by the registrations associated with it.
+     *
+     * If the class is not registered, but it is decorated with {@link AutoRegister},
+     * or {@link ContainerOptions.autoRegister} is true, the class is registered automatically.
+     * Otherwise, resolution fails.
+     * The scope for the automatic registration is determined by either
+     * the {@link Scoped} decorator on the class, or {@link ContainerOptions.defaultScope}.
+     *
+     * If `optional` is false or is not passed and the class is not registered in the container
+     * (and could not be auto-registered), an error is thrown.
+     * Otherwise, if `optional` is true, an empty array is returned.
+     *
+     * The resolution behavior depends on the {@link Provider} used during registration:
+     * - For {@link ValueProvider}, the explicitly provided instance is returned.
+     * - For {@link FactoryProvider}, the factory function is invoked to create the instance.
+     * - For {@link ClassProvider}, a new instance of the class is created according to its scope.
+     * - For {@link ExistingProvider}, the instance is resolved by referring to another registered token.
+     *
+     * If the class is registered with _container_ scope, the resolved instances are cached
+     * in the container's internal registry.
+     *
+     * A separate instance of the class is created for each provider.
+     *
+     * @see The documentation for `resolve(Class: Constructor)`
+     */
+    resolveAll<Instance extends object>(Class: Constructor<Instance>, optional?: false): Instance[];
+    resolveAll<Instance extends object>(Class: Constructor<Instance>, optional: true): Instance[];
+    resolveAll<Instance extends object>(Class: Constructor<Instance>, optional: boolean): Instance[];
+    /**
+     * Resolves the given token to all values provided by the registrations associated with it.
+     *
+     * If `optional` is false or not passed and the token is not registered in the container,
+     * an error is thrown. Otherwise, if `optional` is true, an empty array is returned.
+     *
+     * The resolution behavior depends on the {@link Provider} used during registration:
+     * - For {@link ValueProvider}, the explicitly provided value is returned.
+     * - For {@link FactoryProvider}, the factory function is invoked to create the value.
+     * - For {@link ClassProvider}, a new instance of the class is created according to its scope.
+     * - For {@link ExistingProvider}, the value is resolved by referring to another registered token.
+     *
+     * If the token is registered with _container_ scope, the resolved values are cached
+     * in the container's internal registry.
+     *
+     * @see The documentation for `resolve(token: Token)`
+     */
+    resolveAll<Value>(token: Token<Value>, optional?: false): NonNullable<Value>[];
+    resolveAll<Value>(token: Token<Value>, optional: true): NonNullable<Value>[];
+    resolveAll<Value>(token: Token<Value>, optional: boolean): NonNullable<Value>[];
+    /**
+     * Disposes this container and all its cached values.
+     *
+     * Token values implementing a `Disposable` interface (e.g., objects with a `dispose()` function)
+     * are automatically disposed during this process.
+     *
+     * Note that children containers are disposed first, in creation order.
+     */
+    dispose(): void;
+}
+/**
+ * Creates a new container.
+ */
+declare function createContainer(options?: Partial<ContainerOptions>): Container;
+
+/**
+ * Class decorator for enabling auto-registration of an unregistered class
+ * when first resolving it from the container.
+ *
+ * @example
+ * ```ts
+ * @AutoRegister()
+ * class Wizard {}
+ *
+ * const wizard = container.resolve(Wizard);
+ * container.isRegistered(Wizard); // => true
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function AutoRegister(enable?: boolean): ClassDecorator;
+
+interface TokensRef<Value = any> {
+    readonly getRefTokens: () => Set<Token<Value>>;
+}
+interface TokenRef<Value = any> {
+    readonly getRefToken: () => Token<Value>;
+}
+/**
+ * Allows referencing a token that is declared later in the file by wrapping it in a function.
+ */
+declare function forwardRef<Value>(token: () => Tokens<Value>): TokensRef<Value>;
+declare function forwardRef<Value>(token: () => Token<Value>): TokenRef<Value>;
+
+/**
+ * Parameter decorator that injects the instance associated with the given class.
+ *
+ * Throws an error if the class is not registered in the container.
+ */
+declare function Inject<Instance extends object>(Class: Constructor<Instance>): ParameterDecorator;
+/**
+ * Parameter decorator that injects the value associated with the given token.
+ *
+ * Throws an error if the token is not registered in the container.
+ */
+declare function Inject<Value>(token: Token<Value>): ParameterDecorator;
+/**
+ * Parameter decorator that injects the value associated with the given token.
+ *
+ * Allows referencing a token that is declared later in the file by using
+ * the {@link forwardRef} helper function.
+ *
+ * Throws an error if the token is not registered in the container.
+ *
+ * @example
+ * ```ts
+ * class Wizard {
+ *   constructor(@Inject(forwardRef(() => Wand)) readonly wand: Wand) {}
+ * }
+ * // Other code...
+ * class Wand {}
+ * ```
+ */
+declare function Inject<Value>(tokens: TokenRef<Value>): ParameterDecorator;
+
+/**
+ * Class decorator for registering additional aliasing tokens for the decorated type
+ * when registering it.
+ *
+ * The container uses {@link ExistingProvider} under the hood.
+ *
+ * @example
+ * ```ts
+ * @Injectable(Weapon)
+ * class Wand {}
+ * ```
+ */
+declare function Injectable<This extends object, Value extends This>(...tokens: Tokens<Value>): ClassDecorator;
+/**
+ * Class decorator for registering additional aliasing tokens for the decorated type
+ * when registering it.
+ *
+ * The container uses {@link ExistingProvider} under the hood.
+ *
+ * Allows referencing tokens that are declared later in the file by using
+ * the {@link forwardRef} helper function.
+ *
+ * @example
+ * ```ts
+ * @Injectable(forwardRef() => Weapon) // Weapon is declared after Wand
+ * class Wizard {}
+ * // Other code...
+ * class Weapon {}
+ * ```
+ */
+declare function Injectable<This extends object, Value extends This>(tokens: TokenRef<Value> | TokensRef<Value>): ClassDecorator;
+
+/**
+ * Parameter decorator that injects all instances provided by the registrations
+ * associated with the given class.
+ *
+ * Throws an error if the class is not registered in the container.
+ */
+declare function InjectAll<Instance extends object>(Class: Constructor<Instance>): ParameterDecorator;
+/**
+ * Parameter decorator that injects all values provided by the registrations
+ * associated with the given token.
+ *
+ * Throws an error if the token is not registered in the container.
+ */
+declare function InjectAll<Value>(token: Token<Value>): ParameterDecorator;
+/**
+ * Parameter decorator that injects all values provided by the registrations
+ * associated with the given token.
+ *
+ * Allows referencing a token that is declared later in the file by using
+ * the {@link forwardRef} helper function.
+ *
+ * Throws an error if the token is not registered in the container.
+ *
+ * @example
+ * ```ts
+ * class Wizard {
+ *   constructor(@InjectAll(forwardRef(() => Wand)) readonly wands: Wand[]) {}
+ * }
+ * // Other code...
+ * class Wand {}
+ * ```
+ */
+declare function InjectAll<Value>(tokens: TokenRef<Value>): ParameterDecorator;
+
+/**
+ * Parameter decorator that injects the instance associated with the given class,
+ * or `undefined` if the class is not registered in the container.
+ */
+declare function Optional<Instance extends object>(Class: Constructor<Instance>): ParameterDecorator;
+/**
+ * Parameter decorator that injects the value associated with the given token,
+ * or `undefined` if the token is not registered in the container.
+ */
+declare function Optional<Value>(token: Token<Value>): ParameterDecorator;
+/**
+ * Parameter decorator that injects the value associated with the given token,
+ * or `undefined` if the token is not registered in the container.
+ *
+ * Allows referencing a token that is declared later in the file by using
+ * the {@link forwardRef} helper function.
+ *
+ * @example
+ * ```ts
+ * class Wizard {
+ *   constructor(@Optional(forwardRef(() => Wand)) readonly wand: Wand | undefined) {}
+ * }
+ * // Other code...
+ * class Wand {}
+ * ```
+ */
+declare function Optional<Value>(tokens: TokenRef<Value>): ParameterDecorator;
+
+/**
+ * Parameter decorator that injects all instances provided by the registrations
+ * associated with the given class, or an empty array if the class is not registered
+ * in the container.
+ */
+declare function OptionalAll<Instance extends object>(Class: Constructor<Instance>): ParameterDecorator;
+/**
+ * Parameter decorator that injects all values provided by the registrations
+ * associated with the given token, or an empty array if the token is not registered
+ * in the container.
+ */
+declare function OptionalAll<Value>(token: Token<Value>): ParameterDecorator;
+/**
+ * Parameter decorator that injects all values provided by the registrations
+ * associated with the given token, or an empty array if the token is not registered
+ * in the container.
+ *
+ * Allows referencing a token that is declared later in the file by using
+ * the {@link forwardRef} helper function.
+ *
+ * @example
+ * ```ts
+ * class Wizard {
+ *   constructor(@OptionalAll(forwardRef(() => Wand)) readonly wands: Wand[]) {}
+ * }
+ * // Other code...
+ * class Wand {}
+ * ```
+ */
+declare function OptionalAll<Value>(tokens: TokenRef<Value>): ParameterDecorator;
+
+/**
+ * Class decorator for setting the scope of the decorated type when registering it.
+ *
+ * The scope set by this decorator can be overridden by explicit registration options, if provided.
+ *
+ * @example
+ * ```ts
+ * @Scoped(Scope.Container)
+ * class Wizard {}
+ *
+ * container.register(Wizard);
+ *
+ * // Under the hood
+ * container.register(
+ *   Wizard,
+ *   { useClass: Wizard },
+ *   { scope: Scope.Container },
+ * );
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function Scoped(scope: Scope): ClassDecorator;
+
+/**
+ * Injects the instance associated with the given class.
+ *
+ * Throws an error if the class is not registered in the container.
+ */
+declare function inject<Instance extends object>(Class: Constructor<Instance>): Instance;
+/**
+ * Injects the value associated with the given token.
+ *
+ * Throws an error if the token is not registered in the container.
+ */
+declare function inject<Value>(token: Token<Value>): Value;
+/**
+ * Injects the instance associated with the given class.
+ *
+ * Throws an error if the class is not registered in the container.
+ *
+ * Compared to {@link inject}, `injectBy` accepts a `thisArg` argument
+ * (the containing class) which is used to resolve circular dependencies.
+ *
+ * @example
+ * ```ts
+ * class Wand {
+ *   owner = inject(Wizard);
+ * }
+ *
+ * class Wizard {
+ *   wand = injectBy(this, Wand);
+ * }
+ * ```
+ *
+ * @param thisArg - The containing instance, used to help resolve circular dependencies.
+ * @param Class - The class to resolve.
+ */
+declare function injectBy<Instance extends object>(thisArg: any, Class: Constructor<Instance>): Instance;
+/**
+ * Injects the value associated with the given token.
+ *
+ * Throws an error if the token is not registered in the container.
+ *
+ * Compared to {@link inject}, `injectBy` accepts a `thisArg` argument
+ * (the containing class) which is used to resolve circular dependencies.
+ *
+ * @example
+ * ```ts
+ * class Wand {
+ *   owner = inject(Wizard);
+ * }
+ *
+ * class Wizard {
+ *   wand = injectBy(this, Wand);
+ * }
+ * ```
+ *
+ * @param thisArg - The containing instance, used to help resolve circular dependencies.
+ * @param token - The token to resolve.
+ */
+declare function injectBy<Value>(thisArg: any, token: Token<Value>): Value;
+
+/**
+ * Injects all instances provided by the registrations associated with the given class.
+ *
+ * Throws an error if the class is not registered in the container.
+ */
+declare function injectAll<Instance extends object>(Class: Constructor<Instance>): Instance[];
+/**
+ * Injects all values provided by the registrations associated with the given token.
+ *
+ * Throws an error if the token is not registered in the container.
+ */
+declare function injectAll<Value>(token: Token<Value>): NonNullable<Value>[];
+
+/**
+ * Injector API.
+ */
+interface Injector {
+    /**
+     * Injects the instance associated with the given class.
+     *
+     * Throws an error if the class is not registered in the container.
+     */
+    inject<Instance extends object>(Class: Constructor<Instance>): Instance;
+    /**
+     * Injects the value associated with the given token.
+     *
+     * Throws an error if the token is not registered in the container.
+     */
+    inject<Value>(token: Token<Value>): Value;
+    /**
+     * Injects all instances provided by the registrations associated with the given class.
+     *
+     * Throws an error if the class is not registered in the container.
+     */
+    injectAll<Instance extends object>(Class: Constructor<Instance>): Instance[];
+    /**
+     * Injects all values provided by the registrations associated with the given token.
+     *
+     * Throws an error if the token is not registered in the container.
+     */
+    injectAll<Value>(token: Token<Value>): NonNullable<Value>[];
+    /**
+     * Injects the instance associated with the given class,
+     * or `undefined` if the class is not registered in the container.
+     */
+    optional<Instance extends object>(Class: Constructor<Instance>): Instance | undefined;
+    /**
+     * Injects the value associated with the given token,
+     * or `undefined` if the token is not registered in the container.
+     */
+    optional<Value>(token: Token<Value>): Value | undefined;
+    /**
+     * Injects all instances provided by the registrations associated with the given class,
+     * or an empty array if the class is not registered in the container.
+     */
+    optionalAll<Instance extends object>(Class: Constructor<Instance>): Instance[];
+    /**
+     * Injects all values provided by the registrations associated with the given token,
+     * or an empty array if the token is not registered in the container.
+     */
+    optionalAll<Value>(token: Token<Value>): NonNullable<Value>[];
+}
+/**
+ * Injector token for dynamic injections.
+ *
+ * @example
+ * ```ts
+ * class Wizard {
+ *   private injector = inject(Injector);
+ *   private wand?: Wand;
+ *
+ *   getWand(): Wand {
+ *     return (this.wand ??= this.injector.inject(Wand));
+ *   }
+ * }
+ *
+ * const wizard = container.resolve(Wizard);
+ * wizard.getWand(); // => Wand
+ * ```
+ */
+declare const Injector: Type<Injector>;
+
+/**
+ * Composer API for middleware functions.
+ */
+interface MiddlewareComposer {
+    /**
+     * Add a middleware function to the composer.
+     */
+    use<MethodKey extends keyof Container>(key: MethodKey, wrap: Container[MethodKey] extends Function ? (next: Container[MethodKey]) => Container[MethodKey] : never): MiddlewareComposer;
+}
+/**
+ * Middleware function that can be used to extend the container.
+ *
+ * @example
+ * ```ts
+ * const logger: Middleware = (composer, _api) => {
+ *   composer
+ *     .use("resolve", (next) => (...args) => {
+ *       console.log("resolve", args);
+ *       return next(...args);
+ *     })
+ *     .use("resolveAll", (next) => (...args) => {
+ *       console.log("resolveAll", args);
+ *       return next(...args);
+ *     });
+ * };
+ * ```
+ */
+interface Middleware {
+    (composer: MiddlewareComposer, api: Readonly<Container>): void;
+}
+/**
+ * Apply middleware functions to a container.
+ *
+ * Middlewares are applied in array order, but execute in reverse order.
+ *
+ * @example
+ * ```ts
+ * const container = applyMiddleware(
+ *   createContainer(),
+ *   [A, B],
+ * );
+ * ```
+ *
+ * The execution order will be:
+ *
+ * 1. B before
+ * 2. A before
+ * 3. original function
+ * 4. A after
+ * 5. B after
+ *
+ * This allows outer middlewares to wrap and control the behavior of inner middlewares.
+ */
+declare function applyMiddleware(container: Container, middlewares: Middleware[]): Container;
+
+export { AutoRegister, Build, Inject, InjectAll, Injectable, Injector, Optional, OptionalAll, Scope, Scoped, Type, applyMiddleware, createContainer, forwardRef, inject, injectAll, injectBy };
+export type { ClassProvider, Constructor, Container, ContainerOptions, ExistingProvider, FactoryProvider, Middleware, MiddlewareComposer, Provider, RegistrationOptions, Token, TokenRef, Tokens, TokensRef, ValueProvider };