@expressots/core 3.0.0-beta.4 → 4.0.0-preview.1

package/lib/esm/types/di/annotation/pre_destroy.d.ts

@@ -0,0 +1,4 @@
+declare const preDestroy: () => (target: {
+    constructor: NewableFunction;
+}, propertyKey: string) => void;
+export { preDestroy };

package/lib/esm/types/di/annotation/property_event_decorator.d.ts

@@ -0,0 +1,4 @@
+declare function propertyEventDecorator(eventKey: string, errorMessage: string): () => (target: {
+    constructor: NewableFunction;
+}, propertyKey: string) => void;
+export { propertyEventDecorator };

package/lib/esm/types/di/annotation/tagged.d.ts

@@ -0,0 +1,2 @@
+declare function tagged<T>(metadataKey: string | number | symbol, metadataValue: T | unknown): ParameterDecorator;
+export { tagged };

package/lib/esm/types/di/annotation/target_name.d.ts

@@ -0,0 +1,3 @@
+import { DecoratorTarget } from "./decorator_utils.js";
+declare function targetName(name: string): (target: DecoratorTarget, targetKey: string, index: number) => void;
+export { targetName };

package/lib/esm/types/di/annotation/unmanaged.d.ts

@@ -0,0 +1,3 @@
+import { DecoratorTarget } from "./decorator_utils.js";
+declare function unmanaged(): (target: DecoratorTarget, targetKey: string | undefined, index: number) => void;
+export { unmanaged };

package/lib/esm/types/di/binding-decorator/constants.d.ts

@@ -0,0 +1,7 @@
+declare const METADATA_KEY: {
+    provide: string;
+    scope: string;
+    source: string;
+    providerMeta: string;
+};
+export { METADATA_KEY };

package/lib/esm/types/di/binding-decorator/decorator/fluent_provide.d.ts

@@ -0,0 +1,4 @@
+import interfaces from "../interfaces/interfaces.js";
+import { interfaces as inversifyInterfaces } from "../../../di/inversify.js";
+declare function fluentProvide(serviceIdentifier: inversifyInterfaces.ServiceIdentifier<any>): interfaces.ProvideInWhenOnSyntax<any>;
+export default fluentProvide;

package/lib/esm/types/di/binding-decorator/decorator/provide.d.ts

@@ -0,0 +1,4 @@
+import "reflect-metadata";
+import { interfaces as inversifyInterfaces } from "../../../di/inversify.js";
+declare function provide(serviceIdentifier: inversifyInterfaces.ServiceIdentifier<any>, force?: boolean): any;
+export default provide;

package/lib/esm/types/di/binding-decorator/factory/module_factory.d.ts

@@ -0,0 +1,23 @@
+import "reflect-metadata";
+import { interfaces as inversifyInterfaces } from "../../inversify.js";
+/**
+ * Builds a ContainerModule from all @provide() decorated classes.
+ *
+ * @layer internal
+ * @audience framework-developers
+ *
+ * **Internal Behavior**
+ * - Discovers all classes decorated with @provide() or fluentProvide()
+ * - Creates bindings for each discovered provider
+ * - Returns ContainerModule that can be loaded into container
+ *
+ * **Used By**
+ * - AppContainer automatically loads this module
+ * - Provides auto-discovery of providers
+ *
+ * @returns ContainerModule with all provider bindings
+ *
+ * @internal
+ */
+declare function buildProviderModule(): inversifyInterfaces.ContainerModule;
+export default buildProviderModule;

package/lib/esm/types/di/binding-decorator/index.d.ts

@@ -0,0 +1,10 @@
+import autoProvide from "./utils/auto_wire.js";
+import provide from "./decorator/provide.js";
+import fluentProvide from "./decorator/fluent_provide.js";
+import buildProviderModule from "./factory/module_factory.js";
+import { METADATA_KEY } from "./constants.js";
+export { fluentProvide };
+export { provide };
+export { autoProvide };
+export { buildProviderModule };
+export { METADATA_KEY };

package/lib/esm/types/di/binding-decorator/interfaces/interfaces.d.ts

@@ -0,0 +1,40 @@
+import { interfaces as inversifyInterfaces } from "../../inversify.js";
+declare namespace interfaces {
+    type BindConstraint = (bind: inversifyInterfaces.Bind, target: any) => any;
+    interface ProvideSyntax {
+        constraint: BindConstraint;
+        implementationType: any;
+    }
+    interface ProvideDoneSyntax {
+        done(force?: boolean): (target: any) => any;
+    }
+    interface ProvideInSyntax<T> extends ProvideDoneSyntax {
+        inSingletonScope(): ProvideWhenOnSyntax<T>;
+        inTransientScope(): ProvideWhenOnSyntax<T>;
+        inScope(scope: string): ProvideWhenOnSyntax<T>;
+    }
+    interface ProvideInWhenOnSyntax<T> extends ProvideInSyntax<T>, ProvideWhenSyntax<T>, ProvideOnSyntax<T> {
+    }
+    interface ProvideOnSyntax<T> extends ProvideDoneSyntax {
+        onActivation(fn: (context: inversifyInterfaces.Context, injectable: T) => T): ProvideWhenSyntax<T>;
+    }
+    interface ProvideWhenSyntax<T> extends ProvideDoneSyntax {
+        when(constraint: (request: inversifyInterfaces.Request) => boolean): ProvideOnSyntax<T>;
+        whenTargetNamed(name: string): ProvideOnSyntax<T>;
+        whenTargetTagged(tag: string, value: any): ProvideOnSyntax<T>;
+        whenInjectedInto(parent: Function | string): ProvideOnSyntax<T>;
+        whenParentNamed(name: string): ProvideOnSyntax<T>;
+        whenParentTagged(tag: string, value: any): ProvideOnSyntax<T>;
+        whenAnyAncestorIs(ancestor: Function | string): ProvideOnSyntax<T>;
+        whenNoAncestorIs(ancestor: Function | string): ProvideOnSyntax<T>;
+        whenAnyAncestorNamed(name: string): ProvideOnSyntax<T>;
+        whenAnyAncestorTagged(tag: string, value: any): ProvideOnSyntax<T>;
+        whenNoAncestorNamed(name: string): ProvideOnSyntax<T>;
+        whenNoAncestorTagged(tag: string, value: any): ProvideOnSyntax<T>;
+        whenAnyAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): ProvideOnSyntax<T>;
+        whenNoAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): ProvideOnSyntax<T>;
+    }
+    interface ProvideWhenOnSyntax<T> extends ProvideWhenSyntax<T>, ProvideOnSyntax<T> {
+    }
+}
+export default interfaces;

package/lib/esm/types/di/binding-decorator/syntax/provide_done_syntax.d.ts

@@ -0,0 +1,7 @@
+import interfaces from "../interfaces/interfaces.js";
+declare class ProvideDoneSyntax implements interfaces.ProvideDoneSyntax {
+    private _binding;
+    constructor(binding: interfaces.BindConstraint);
+    done(force?: boolean): (target: any) => any;
+}
+export default ProvideDoneSyntax;

package/lib/esm/types/di/binding-decorator/syntax/provide_in_syntax.d.ts

@@ -0,0 +1,12 @@
+import interfaces from "../interfaces/interfaces.js";
+import { interfaces as inversifyInterfaces } from "../../inversify.js";
+declare class ProvideInSyntax<T> implements interfaces.ProvideInSyntax<T> {
+    private _bindingInSyntax;
+    private _provideDoneSyntax;
+    constructor(bindingInSyntax: (bind: inversifyInterfaces.Bind, target: any) => inversifyInterfaces.BindingInSyntax<T>, provideDoneSyntax: interfaces.ProvideDoneSyntax);
+    inSingletonScope(): interfaces.ProvideWhenOnSyntax<T>;
+    inTransientScope(): interfaces.ProvideWhenOnSyntax<T>;
+    inScope(scope: string): interfaces.ProvideWhenOnSyntax<T>;
+    done(force?: boolean): any;
+}
+export default ProvideInSyntax;

package/lib/esm/types/di/binding-decorator/syntax/provide_in_when_on_syntax.d.ts

@@ -0,0 +1,28 @@
+import interfaces from "../interfaces/interfaces.js";
+import { interfaces as inversifyInterfaces } from "../../inversify.js";
+declare class ProvideInWhenOnSyntax<T> implements interfaces.ProvideInWhenOnSyntax<T> {
+    private _provideInSyntax;
+    private _provideWhenSyntax;
+    private _provideOnSyntax;
+    constructor(provideInSyntax: interfaces.ProvideInSyntax<T>, provideWhenSyntax: interfaces.ProvideWhenSyntax<T>, provideOnSyntax: interfaces.ProvideOnSyntax<T>);
+    when(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    whenTargetNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenTargetTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenInjectedInto(parent: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenParentNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenParentTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorIs(ancestor: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    onActivation(fn: (context: inversifyInterfaces.Context, injectable: T) => T): interfaces.ProvideWhenSyntax<T>;
+    inSingletonScope(): interfaces.ProvideWhenOnSyntax<T>;
+    inTransientScope(): interfaces.ProvideWhenOnSyntax<T>;
+    inScope(scope: string): interfaces.ProvideWhenOnSyntax<T>;
+    done(force?: boolean): any;
+}
+export default ProvideInWhenOnSyntax;

package/lib/esm/types/di/binding-decorator/syntax/provide_on_syntax.d.ts

@@ -0,0 +1,10 @@
+import interfaces from "../interfaces/interfaces.js";
+import { interfaces as inversifyInterfaces } from "../../inversify.js";
+declare class ProvideOnSyntax<T> implements interfaces.ProvideOnSyntax<T> {
+    private _bindingOnSyntax;
+    private _provideDoneSyntax;
+    constructor(bindingOnSyntax: (bind: inversifyInterfaces.Bind, target: any) => inversifyInterfaces.BindingOnSyntax<T>, provideDoneSyntax: interfaces.ProvideDoneSyntax);
+    onActivation(fn: (context: inversifyInterfaces.Context, injectable: T) => T): interfaces.ProvideWhenSyntax<T>;
+    done(force?: boolean): any;
+}
+export default ProvideOnSyntax;

package/lib/esm/types/di/binding-decorator/syntax/provide_when_on_syntax.d.ts

@@ -0,0 +1,24 @@
+import interfaces from "../interfaces/interfaces.js";
+import { interfaces as inversifyInterfaces } from "../../inversify.js";
+declare class ProvideWhenOnSyntax<T> implements interfaces.ProvideWhenOnSyntax<T> {
+    private _provideWhenSyntax;
+    private _provideOnSyntax;
+    constructor(provideWhenSyntax: interfaces.ProvideWhenSyntax<T>, provideOnSyntax: interfaces.ProvideOnSyntax<T>);
+    when(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    whenTargetNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenTargetTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenInjectedInto(parent: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenParentNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenParentTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorIs(ancestor: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    onActivation(fn: (context: inversifyInterfaces.Context, injectable: T) => T): interfaces.ProvideWhenSyntax<T>;
+    done(force?: boolean): any;
+}
+export default ProvideWhenOnSyntax;

package/lib/esm/types/di/binding-decorator/syntax/provide_when_syntax.d.ts

@@ -0,0 +1,23 @@
+import interfaces from "../interfaces/interfaces.js";
+import { interfaces as inversifyInterfaces } from "../../inversify.js";
+declare class ProvideWhenSyntax<T> implements interfaces.ProvideWhenSyntax<T> {
+    private _bindingWhenSyntax;
+    private _provideDoneSyntax;
+    constructor(bindingWhenSyntax: (bind: inversifyInterfaces.Bind, target: any) => inversifyInterfaces.BindingWhenSyntax<T>, provideDoneSyntax: interfaces.ProvideDoneSyntax);
+    when(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    whenTargetNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenTargetTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenInjectedInto(parent: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenParentNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenParentTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorIs(ancestor: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    done(force?: boolean): (target: any) => any;
+}
+export default ProvideWhenSyntax;

package/lib/esm/types/di/binding-decorator/utils/auto_wire.d.ts

@@ -0,0 +1,3 @@
+import { interfaces } from "../../inversify.js";
+declare function autoProvide(container: interfaces.Container, ...modules: Array<any>): void;
+export default autoProvide;

package/lib/esm/types/di/bindings/binding.d.ts

@@ -0,0 +1,20 @@
+import { interfaces } from "../interfaces/interfaces.js";
+declare class Binding<TActivated> implements interfaces.Binding<TActivated> {
+    id: number;
+    moduleId: interfaces.ContainerModuleBase["id"];
+    activated: boolean;
+    serviceIdentifier: interfaces.ServiceIdentifier<TActivated>;
+    implementationType: interfaces.Newable<TActivated> | TActivated | null;
+    cache: TActivated | Promise<TActivated> | null;
+    dynamicValue: interfaces.DynamicValue<TActivated> | null;
+    scope: interfaces.BindingScope;
+    type: interfaces.BindingType;
+    factory: interfaces.FactoryCreator<unknown> | null;
+    provider: interfaces.ProviderCreator<unknown> | null;
+    constraint: interfaces.ConstraintFunction;
+    onActivation: interfaces.BindingActivation<TActivated> | null;
+    onDeactivation: interfaces.BindingDeactivation<TActivated> | null;
+    constructor(serviceIdentifier: interfaces.ServiceIdentifier<TActivated>, scope: interfaces.BindingScope);
+    clone(): interfaces.Binding<TActivated>;
+}
+export { Binding };

package/lib/esm/types/di/bindings/binding_count.d.ts

@@ -0,0 +1,5 @@
+export declare const BindingCount: {
+    MultipleBindingsAvailable: number;
+    NoBindingsAvailable: number;
+    OnlyOneBindingAvailable: number;
+};

package/lib/esm/types/di/constants/error_msgs.d.ts

@@ -0,0 +1,32 @@
+export declare const DUPLICATED_INJECTABLE_DECORATOR = "Cannot apply @injectable decorator multiple times.";
+export declare const DUPLICATED_METADATA = "Metadata key was used more than once in a parameter:";
+export declare const NULL_ARGUMENT = "NULL argument";
+export declare const KEY_NOT_FOUND = "Key Not Found";
+export declare const AMBIGUOUS_MATCH = "Ambiguous match found for serviceIdentifier:";
+export declare const CANNOT_UNBIND = "Could not unbind serviceIdentifier:";
+export declare const NOT_REGISTERED = "No matching bindings found for serviceIdentifier:";
+export declare const MISSING_INJECTABLE_ANNOTATION = "Missing required @injectable annotation in:";
+export declare const MISSING_INJECT_ANNOTATION = "Missing required @inject or @multiInject annotation in:";
+export declare const UNDEFINED_INJECT_ANNOTATION: (name: string) => string;
+export declare const CIRCULAR_DEPENDENCY = "Circular dependency found:";
+export declare const NOT_IMPLEMENTED = "Sorry, this feature is not fully implemented yet.";
+export declare const INVALID_BINDING_TYPE = "Invalid binding type:";
+export declare const NO_MORE_SNAPSHOTS_AVAILABLE = "No snapshot available to restore.";
+export declare const INVALID_MIDDLEWARE_RETURN = "Invalid return type in middleware. Middleware must return!";
+export declare const INVALID_FUNCTION_BINDING = "Value provided to function binding must be a function!";
+export declare const LAZY_IN_SYNC: (key: unknown) => string;
+export declare const INVALID_TO_SELF_VALUE: string;
+export declare const INVALID_DECORATOR_OPERATION: string;
+export declare const ARGUMENTS_LENGTH_MISMATCH: (...values: Array<unknown>) => string;
+export declare const CONTAINER_OPTIONS_MUST_BE_AN_OBJECT: string;
+export declare const CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE: string;
+export declare const CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE: string;
+export declare const CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK: string;
+export declare const MULTIPLE_PRE_DESTROY_METHODS = "Cannot apply @preDestroy decorator multiple times in the same class";
+export declare const MULTIPLE_POST_CONSTRUCT_METHODS = "Cannot apply @postConstruct decorator multiple times in the same class";
+export declare const ASYNC_UNBIND_REQUIRED = "Attempting to unbind dependency with asynchronous destruction (@preDestroy or onDeactivation)";
+export declare const POST_CONSTRUCT_ERROR: (clazz: string, errorMessage: string) => string;
+export declare const PRE_DESTROY_ERROR: (clazz: string, errorMessage: string) => string;
+export declare const ON_DEACTIVATION_ERROR: (clazz: string, errorMessage: string) => string;
+export declare const CIRCULAR_DEPENDENCY_IN_FACTORY: (factoryType: string, serviceIdentifier: string) => string;
+export declare const STACK_OVERFLOW = "Maximum call stack size exceeded";

package/lib/esm/types/di/constants/literal_types.d.ts

@@ -0,0 +1,5 @@
+import { interfaces } from "../interfaces/interfaces.js";
+declare const Scope: interfaces.Scope;
+declare const BindingTypeEnum: interfaces.BindingTypeEnum;
+declare const TargetTypeEnum: interfaces.TargetTypeEnum;
+export { Scope, BindingTypeEnum, TargetTypeEnum };

package/lib/esm/types/di/constants/metadata_keys.d.ts

@@ -0,0 +1,13 @@
+export declare const NAMED_TAG = "named";
+export declare const NAME_TAG = "name";
+export declare const UNMANAGED_TAG = "unmanaged";
+export declare const OPTIONAL_TAG = "optional";
+export declare const INJECT_TAG = "inject";
+export declare const MULTI_INJECT_TAG = "multi_inject";
+export declare const TAGGED = "inversify:tagged";
+export declare const TAGGED_PROP = "inversify:tagged_props";
+export declare const PARAM_TYPES = "inversify:paramtypes";
+export declare const DESIGN_PARAM_TYPES = "design:paramtypes";
+export declare const POST_CONSTRUCT = "post_construct";
+export declare const PRE_DESTROY = "pre_destroy";
+export declare const NON_CUSTOM_TAG_KEYS: Array<string>;

package/lib/esm/types/di/container/container.d.ts

@@ -0,0 +1,73 @@
+import { interfaces } from "../interfaces/interfaces.js";
+declare class Container implements interfaces.Container {
+    id: number;
+    parent: interfaces.Container | null;
+    readonly options: interfaces.ContainerOptions;
+    private _middleware;
+    private _bindingDictionary;
+    private _activations;
+    private _deactivations;
+    private _snapshots;
+    private _metadataReader;
+    private _moduleActivationStore;
+    static merge(container1: interfaces.Container, container2: interfaces.Container, ...containers: Array<interfaces.Container>): interfaces.Container;
+    constructor(containerOptions?: interfaces.ContainerOptions);
+    load(...modules: Array<interfaces.ContainerModule>): void;
+    loadAsync(...modules: Array<interfaces.AsyncContainerModule>): Promise<void>;
+    unload(...modules: Array<interfaces.ContainerModuleBase>): void;
+    unloadAsync(...modules: Array<interfaces.ContainerModuleBase>): Promise<void>;
+    bind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;
+    rebind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;
+    rebindAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Promise<interfaces.BindingToSyntax<T>>;
+    unbind(serviceIdentifier: interfaces.ServiceIdentifier): void;
+    unbindAsync(serviceIdentifier: interfaces.ServiceIdentifier): Promise<void>;
+    unbindAll(): void;
+    unbindAllAsync(): Promise<void>;
+    onActivation<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, onActivation: interfaces.BindingActivation<T>): void;
+    onDeactivation<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, onDeactivation: interfaces.BindingDeactivation<T>): void;
+    isBound(serviceIdentifier: interfaces.ServiceIdentifier<unknown>): boolean;
+    isCurrentBound<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): boolean;
+    isBoundNamed(serviceIdentifier: interfaces.ServiceIdentifier, named: string | number | symbol): boolean;
+    isBoundTagged(serviceIdentifier: interfaces.ServiceIdentifier, key: string | number | symbol, value: unknown): boolean;
+    snapshot(): void;
+    restore(): void;
+    createChild(containerOptions?: interfaces.ContainerOptions): Container;
+    applyMiddleware(...middlewares: Array<interfaces.Middleware>): void;
+    applyCustomMetadataReader(metadataReader: interfaces.MetadataReader): void;
+    get<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T;
+    getAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Promise<T>;
+    getTagged<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: unknown): T;
+    getTaggedAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Promise<T>;
+    getNamed<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): T;
+    getNamedAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): Promise<T>;
+    getAll<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Array<T>;
+    getAllAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Promise<Array<T>>;
+    getAllTagged<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Array<T>;
+    getAllTaggedAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Promise<Array<T>>;
+    getAllNamed<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): Array<T>;
+    getAllNamedAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): Promise<Array<T>>;
+    resolve<T>(constructorFunction: interfaces.Newable<T>): T;
+    private _preDestroy;
+    private _removeModuleHandlers;
+    private _removeModuleBindings;
+    private _deactivate;
+    private _handleDeactivationError;
+    private _deactivateContainer;
+    private _deactivateContainerAsync;
+    private _getContainerModuleHelpersFactory;
+    private _getAll;
+    private _get;
+    private _getButThrowIfAsync;
+    private _getAllArgs;
+    private _getNotAllArgs;
+    private _planAndResolve;
+    private _deactivateIfSingleton;
+    private _deactivateSingletons;
+    private _deactivateSingletonsAsync;
+    private _propagateContainerDeactivationThenBindingAndPreDestroy;
+    private _propagateContainerDeactivationThenBindingAndPreDestroyAsync;
+    private _removeServiceFromDictionary;
+    private _bindingDeactivationAndPreDestroy;
+    private _bindingDeactivationAndPreDestroyAsync;
+}
+export { Container };

package/lib/esm/types/di/container/container_module.d.ts

@@ -0,0 +1,11 @@
+import { interfaces } from "../interfaces/interfaces.js";
+export declare class ContainerModule implements interfaces.ContainerModule {
+    id: number;
+    registry: interfaces.ContainerModuleCallBack;
+    constructor(registry: interfaces.ContainerModuleCallBack);
+}
+export declare class AsyncContainerModule implements interfaces.AsyncContainerModule {
+    id: number;
+    registry: interfaces.AsyncContainerModuleCallBack;
+    constructor(registry: interfaces.AsyncContainerModuleCallBack);
+}

package/lib/esm/types/di/container/container_snapshot.d.ts

@@ -0,0 +1,10 @@
+import { interfaces } from "../interfaces/interfaces.js";
+declare class ContainerSnapshot implements interfaces.ContainerSnapshot {
+    bindings: interfaces.Lookup<interfaces.Binding<unknown>>;
+    activations: interfaces.Lookup<interfaces.BindingActivation<unknown>>;
+    deactivations: interfaces.Lookup<interfaces.BindingDeactivation<unknown>>;
+    middleware: interfaces.Next | null;
+    moduleActivationStore: interfaces.ModuleActivationStore;
+    static of(bindings: interfaces.Lookup<interfaces.Binding<unknown>>, middleware: interfaces.Next | null, activations: interfaces.Lookup<interfaces.BindingActivation<unknown>>, deactivations: interfaces.Lookup<interfaces.BindingDeactivation<unknown>>, moduleActivationStore: interfaces.ModuleActivationStore): ContainerSnapshot;
+}
+export { ContainerSnapshot };

package/lib/esm/types/di/container/lookup.d.ts

@@ -0,0 +1,16 @@
+import { interfaces } from "../interfaces/interfaces.js";
+declare class Lookup<T> implements interfaces.Lookup<T> {
+    private _map;
+    constructor();
+    getMap(): Map<interfaces.ServiceIdentifier, Array<T>>;
+    add(serviceIdentifier: interfaces.ServiceIdentifier, value: T): void;
+    get(serviceIdentifier: interfaces.ServiceIdentifier): Array<T>;
+    remove(serviceIdentifier: interfaces.ServiceIdentifier): void;
+    removeIntersection(lookup: interfaces.Lookup<T>): void;
+    removeByCondition(condition: (item: T) => boolean): Array<T>;
+    hasKey(serviceIdentifier: interfaces.ServiceIdentifier): boolean;
+    clone(): interfaces.Lookup<T>;
+    traverse(func: (key: interfaces.ServiceIdentifier, value: Array<T>) => void): void;
+    private _setValue;
+}
+export { Lookup };

package/lib/esm/types/di/container/module_activation_store.d.ts

@@ -0,0 +1,10 @@
+import { interfaces } from "../interfaces/interfaces.js";
+export declare class ModuleActivationStore implements interfaces.ModuleActivationStore {
+    private _map;
+    remove(moduleId: number): interfaces.ModuleActivationHandlers;
+    addDeactivation(moduleId: number, serviceIdentifier: interfaces.ServiceIdentifier<unknown>, onDeactivation: interfaces.BindingDeactivation<unknown>): void;
+    addActivation(moduleId: number, serviceIdentifier: interfaces.ServiceIdentifier<unknown>, onActivation: interfaces.BindingActivation<unknown>): void;
+    clone(): interfaces.ModuleActivationStore;
+    private _getModuleActivationHandlers;
+    private _getEmptyHandlersStore;
+}

package/lib/esm/types/di/container-introspection.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Container introspection helpers.
+ *
+ * Centralises the (currently unavoidable) reach into the vendored
+ * Inversify `_bindingDictionary._map`. Concentrating it in one file means
+ * the rest of the framework no longer accesses Inversify internals
+ * directly, and the day we replace or upgrade the DI internals there is
+ * exactly one file to update.
+ *
+ * @public API (advanced) - intentionally exported so user code, the
+ * adapter, and the metrics collector can introspect bindings without
+ * each importing private internals.
+ */
+import type { interfaces } from "./inversify.js";
+/**
+ * Visit every binding in the container, including duplicates registered
+ * for the same service identifier. Returns the total count visited.
+ */
+export declare function forEachBinding(container: interfaces.Container, visit: (binding: interfaces.Binding<unknown>, serviceIdentifier: unknown) => void): number;
+/**
+ * Returns every implementation type currently bound in the container
+ * that is a real constructor function. Filters out factory and value
+ * bindings.
+ */
+export declare function getBoundImplementations(container: interfaces.Container): Array<NewableFunction>;