inversify 6.1.2 → 6.1.3

package/amd/planning/plan.d.ts

@@ -0,0 +1,7 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class Plan implements interfaces.Plan {
+    parentContext: interfaces.Context;
+    rootRequest: interfaces.Request;
+    constructor(parentContext: interfaces.Context, rootRequest: interfaces.Request);
+}
+export { Plan };

package/amd/planning/planner.d.ts

@@ -0,0 +1,5 @@
+import { interfaces } from '../interfaces/interfaces';
+declare function getBindingDictionary(cntnr: interfaces.Container): interfaces.Lookup<interfaces.Binding<unknown>>;
+declare function plan(metadataReader: interfaces.MetadataReader, container: interfaces.Container, isMultiInject: boolean, targetType: interfaces.TargetType, serviceIdentifier: interfaces.ServiceIdentifier, key?: string | number | symbol, value?: unknown, avoidConstraints?: boolean): interfaces.Context;
+declare function createMockRequest(container: interfaces.Container, serviceIdentifier: interfaces.ServiceIdentifier, key: string | number | symbol, value: unknown): interfaces.Request;
+export { plan, createMockRequest, getBindingDictionary };

package/amd/planning/queryable_string.d.ts

@@ -0,0 +1,10 @@
+import { interfaces } from '../interfaces/interfaces';
+export declare class QueryableString implements interfaces.QueryableString {
+    private readonly str;
+    constructor(str: string);
+    startsWith(searchString: string): boolean;
+    endsWith(searchString: string): boolean;
+    contains(searchString: string): boolean;
+    equals(compareString: string): boolean;
+    value(): string;
+}

package/amd/planning/reflection_utils.d.ts

@@ -0,0 +1,5 @@
+import { interfaces } from '../interfaces/interfaces';
+import { getFunctionName } from '../utils/serialization';
+declare function getDependencies(metadataReader: interfaces.MetadataReader, func: NewableFunction): interfaces.Target[];
+declare function getBaseClassDependencyCount(metadataReader: interfaces.MetadataReader, func: NewableFunction): number;
+export { getDependencies, getBaseClassDependencyCount, getFunctionName };

package/amd/planning/request.d.ts

@@ -0,0 +1,14 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class Request implements interfaces.Request {
+    id: number;
+    serviceIdentifier: interfaces.ServiceIdentifier;
+    parentContext: interfaces.Context;
+    parentRequest: interfaces.Request | null;
+    bindings: interfaces.Binding<unknown>[];
+    childRequests: interfaces.Request[];
+    target: interfaces.Target;
+    requestScope: interfaces.RequestScope | null;
+    constructor(serviceIdentifier: interfaces.ServiceIdentifier, parentContext: interfaces.Context, parentRequest: interfaces.Request | null, bindings: interfaces.Binding<any> | interfaces.Binding<any>[], target: interfaces.Target);
+    addChildRequest(serviceIdentifier: interfaces.ServiceIdentifier, bindings: interfaces.Binding<unknown> | interfaces.Binding<unknown>[], target: interfaces.Target): interfaces.Request;
+}
+export { Request };

package/amd/resolution/instantiation.d.ts

@@ -0,0 +1,3 @@
+import { interfaces } from '../interfaces/interfaces';
+declare function resolveInstance<T>(binding: interfaces.Binding<T>, constr: interfaces.Newable<T>, childRequests: interfaces.Request[], resolveRequest: interfaces.ResolveRequestHandler): T | Promise<T>;
+export { resolveInstance };

package/amd/resolution/resolver.d.ts

@@ -0,0 +1,3 @@
+import { interfaces } from '../interfaces/interfaces';
+declare function resolve<T>(context: interfaces.Context): T | Promise<T> | (T | Promise<T>)[];
+export { resolve };

package/amd/scope/scope.d.ts

@@ -0,0 +1,3 @@
+import type { interfaces } from '../interfaces/interfaces';
+export declare const tryGetFromScope: <T>(requestScope: interfaces.RequestScope, binding: interfaces.Binding<T>) => T | Promise<T> | null;
+export declare const saveToScope: <T>(requestScope: interfaces.RequestScope, binding: interfaces.Binding<T>, result: T | Promise<T>) => void;

package/amd/syntax/binding_in_syntax.d.ts

@@ -0,0 +1,9 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class BindingInSyntax<T> implements interfaces.BindingInSyntax<T> {
+    private readonly _binding;
+    constructor(binding: interfaces.Binding<T>);
+    inRequestScope(): interfaces.BindingWhenOnSyntax<T>;
+    inSingletonScope(): interfaces.BindingWhenOnSyntax<T>;
+    inTransientScope(): interfaces.BindingWhenOnSyntax<T>;
+}
+export { BindingInSyntax };

package/amd/syntax/binding_in_when_on_syntax.d.ts

@@ -0,0 +1,29 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class BindingInWhenOnSyntax<T> implements interfaces.BindingInSyntax<T>, interfaces.BindingWhenSyntax<T>, interfaces.BindingOnSyntax<T> {
+    private readonly _bindingInSyntax;
+    private readonly _bindingWhenSyntax;
+    private readonly _bindingOnSyntax;
+    private readonly _binding;
+    constructor(binding: interfaces.Binding<T>);
+    inRequestScope(): interfaces.BindingWhenOnSyntax<T>;
+    inSingletonScope(): interfaces.BindingWhenOnSyntax<T>;
+    inTransientScope(): interfaces.BindingWhenOnSyntax<T>;
+    when(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    whenTargetNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenTargetIsDefault(): interfaces.BindingOnSyntax<T>;
+    whenTargetTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenInjectedInto(parent: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenParentNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenParentTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    onActivation(handler: (context: interfaces.Context, injectable: T) => T | Promise<T>): interfaces.BindingWhenSyntax<T>;
+    onDeactivation(handler: (injectable: T) => void | Promise<void>): interfaces.BindingWhenSyntax<T>;
+}
+export { BindingInWhenOnSyntax };

package/amd/syntax/binding_on_syntax.d.ts

@@ -0,0 +1,8 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class BindingOnSyntax<T> implements interfaces.BindingOnSyntax<T> {
+    private readonly _binding;
+    constructor(binding: interfaces.Binding<T>);
+    onActivation(handler: interfaces.BindingActivation<T>): interfaces.BindingWhenSyntax<T>;
+    onDeactivation(handler: interfaces.BindingDeactivation<T>): interfaces.BindingWhenSyntax<T>;
+}
+export { BindingOnSyntax };

package/amd/syntax/binding_to_syntax.d.ts

@@ -0,0 +1,18 @@
+import { interfaces } from '../interfaces/interfaces';
+import { BindingWhenOnSyntax } from './binding_when_on_syntax';
+declare class BindingToSyntax<T> implements interfaces.BindingToSyntax<T> {
+    private readonly _binding;
+    constructor(binding: interfaces.Binding<T>);
+    to(constructor: interfaces.Newable<T>): interfaces.BindingInWhenOnSyntax<T>;
+    toSelf(): interfaces.BindingInWhenOnSyntax<T>;
+    toConstantValue(value: T): interfaces.BindingWhenOnSyntax<T>;
+    toDynamicValue(func: interfaces.DynamicValue<T>): interfaces.BindingInWhenOnSyntax<T>;
+    toConstructor<T2>(constructor: interfaces.Newable<T2>): interfaces.BindingWhenOnSyntax<T>;
+    toFactory<T2>(factory: interfaces.FactoryCreator<T2>): interfaces.BindingWhenOnSyntax<T>;
+    toFunction(func: T): interfaces.BindingWhenOnSyntax<T>;
+    toAutoFactory<T2>(serviceIdentifier: interfaces.ServiceIdentifier<T2>): interfaces.BindingWhenOnSyntax<T>;
+    toAutoNamedFactory<T2>(serviceIdentifier: interfaces.ServiceIdentifier<T2>): BindingWhenOnSyntax<T>;
+    toProvider<T2>(provider: interfaces.ProviderCreator<T2>): interfaces.BindingWhenOnSyntax<T>;
+    toService(service: interfaces.ServiceIdentifier<T>): void;
+}
+export { BindingToSyntax };

package/amd/syntax/binding_when_on_syntax.d.ts

@@ -0,0 +1,25 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class BindingWhenOnSyntax<T> implements interfaces.BindingWhenSyntax<T>, interfaces.BindingOnSyntax<T> {
+    private readonly _bindingWhenSyntax;
+    private readonly _bindingOnSyntax;
+    private readonly _binding;
+    constructor(binding: interfaces.Binding<T>);
+    when(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    whenTargetNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenTargetIsDefault(): interfaces.BindingOnSyntax<T>;
+    whenTargetTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenInjectedInto(parent: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenParentNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenParentTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    onActivation(handler: (context: interfaces.Context, injectable: T) => T): interfaces.BindingWhenSyntax<T>;
+    onDeactivation(handler: (injectable: T) => Promise<void> | void): interfaces.BindingWhenSyntax<T>;
+}
+export { BindingWhenOnSyntax };

package/amd/syntax/binding_when_syntax.d.ts

@@ -0,0 +1,21 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class BindingWhenSyntax<T> implements interfaces.BindingWhenSyntax<T> {
+    private readonly _binding;
+    constructor(binding: interfaces.Binding<T>);
+    when(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    whenTargetNamed(name: string | number | symbol): interfaces.BindingOnSyntax<T>;
+    whenTargetIsDefault(): interfaces.BindingOnSyntax<T>;
+    whenTargetTagged(tag: string | number | symbol, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenInjectedInto(parent: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenParentNamed(name: string | number | symbol): interfaces.BindingOnSyntax<T>;
+    whenParentTagged(tag: string | number | symbol, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorNamed(name: string | number | symbol): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorNamed(name: string | number | symbol): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorTagged(tag: string | number | symbol, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorTagged(tag: string | number | symbol, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+}
+export { BindingWhenSyntax };

package/amd/syntax/constraint_helpers.d.ts

@@ -0,0 +1,6 @@
+import { interfaces } from '../interfaces/interfaces';
+declare const traverseAncerstors: (request: interfaces.Request, constraint: interfaces.ConstraintFunction) => boolean;
+declare const taggedConstraint: (key: string | number | symbol) => (value: unknown) => interfaces.ConstraintFunction;
+declare const namedConstraint: (value: unknown) => interfaces.ConstraintFunction;
+declare const typeConstraint: (type: NewableFunction | string) => (request: interfaces.Request | null) => boolean;
+export { traverseAncerstors, taggedConstraint, namedConstraint, typeConstraint, };

package/amd/utils/async.d.ts

@@ -0,0 +1,3 @@
+declare function isPromise<T>(object: unknown): object is Promise<T>;
+declare function isPromiseOrContainsPromise<T>(object: unknown): object is Promise<T> | (T | Promise<T>)[];
+export { isPromise, isPromiseOrContainsPromise };

package/amd/utils/binding_utils.d.ts

@@ -0,0 +1,4 @@
+import type { interfaces } from '../interfaces/interfaces';
+export declare const multiBindToService: (container: interfaces.Container) => (service: interfaces.ServiceIdentifier) => (...types: interfaces.ServiceIdentifier[]) => void;
+export declare const ensureFullyBound: <T = unknown>(binding: interfaces.Binding<T>) => void;
+export declare const getFactoryDetails: <T = unknown>(binding: interfaces.Binding<T>) => interfaces.FactoryDetails;

package/amd/utils/clonable.d.ts

@@ -0,0 +1,3 @@
+import { interfaces } from '../interfaces/interfaces';
+declare function isClonable<T>(obj: unknown): obj is interfaces.Clonable<T>;
+export { isClonable };

package/amd/utils/exceptions.d.ts

@@ -0,0 +1,2 @@
+export declare function isStackOverflowException(error: unknown): error is RangeError;
+export declare const tryAndThrowErrorIfStackOverflow: <T>(fn: () => T, errorCallback: () => Error) => T;

package/amd/utils/factory_type.d.ts

@@ -0,0 +1,5 @@
+export declare enum FactoryType {
+    DynamicValue = "toDynamicValue",
+    Factory = "toFactory",
+    Provider = "toProvider"
+}

package/amd/utils/id.d.ts

@@ -0,0 +1,2 @@
+declare function id(): number;
+export { id };

package/amd/utils/js.d.ts

@@ -0,0 +1 @@
+export declare function getFirstArrayDuplicate<T>(array: T[]): T | undefined;

package/amd/utils/serialization.d.ts

@@ -0,0 +1,10 @@
+import { interfaces } from '../interfaces/interfaces';
+declare function getServiceIdentifierAsString(serviceIdentifier: interfaces.ServiceIdentifier): string;
+declare function listRegisteredBindingsForServiceIdentifier(container: interfaces.Container, serviceIdentifier: string, getBindings: <T>(container: interfaces.Container, serviceIdentifier: interfaces.ServiceIdentifier<T>) => interfaces.Binding<T>[]): string;
+declare function circularDependencyToException(request: interfaces.Request): void;
+declare function listMetadataForTarget(serviceIdentifierString: string, target: interfaces.Target): string;
+declare function getFunctionName(func: {
+    name: string | null | undefined;
+}): string;
+declare function getSymbolDescription(symbol: symbol): string;
+export { getFunctionName, getServiceIdentifierAsString, listRegisteredBindingsForServiceIdentifier, listMetadataForTarget, circularDependencyToException, getSymbolDescription, };

package/es/annotation/decorator_utils.d.ts

@@ -0,0 +1,16 @@
+import { interfaces } from '../interfaces/interfaces';
+type Prototype<T> = {
+    [Property in keyof T]: T[Property] extends NewableFunction ? T[Property] : T[Property] | undefined;
+} & {
+    constructor: NewableFunction;
+};
+interface ConstructorFunction<T = Record<string, unknown>> {
+    prototype: Prototype<T>;
+    new (...args: unknown[]): T;
+}
+export type DecoratorTarget<T = unknown> = ConstructorFunction<T> | Prototype<T>;
+declare function tagParameter(annotationTarget: DecoratorTarget, parameterName: string | symbol | undefined, parameterIndex: number, metadata: interfaces.MetadataOrMetadataArray): void;
+declare function tagProperty(annotationTarget: DecoratorTarget, propertyName: string | symbol, metadata: interfaces.MetadataOrMetadataArray): void;
+declare function createTaggedDecorator(metadata: interfaces.MetadataOrMetadataArray): <T>(target: DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;
+declare function decorate(decorator: DecoratorTarget | ParameterDecorator | MethodDecorator, target: object, parameterIndexOrProperty?: number | string): void;
+export { decorate, tagParameter, tagProperty, createTaggedDecorator };

package/es/annotation/inject.d.ts

@@ -0,0 +1,5 @@
+import { LazyServiceIdentifier } from '@inversifyjs/common';
+import { interfaces } from '../interfaces/interfaces';
+import { DecoratorTarget } from './decorator_utils';
+declare const inject: <T = unknown>(serviceIdentifier: interfaces.ServiceIdentifier<T> | LazyServiceIdentifier<T>) => (target: DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;
+export { inject };

package/es/annotation/inject_base.d.ts

@@ -0,0 +1,4 @@
+import { LazyServiceIdentifier } from '@inversifyjs/common';
+import { interfaces } from '../interfaces/interfaces';
+import { DecoratorTarget } from './decorator_utils';
+export declare function injectBase(metadataKey: string): <T = unknown>(serviceIdentifier: interfaces.ServiceIdentifier<T> | LazyServiceIdentifier<T>) => (target: DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;

package/es/annotation/injectable.d.ts

@@ -0,0 +1,2 @@
+declare function injectable(): <T extends abstract new (...args: any) => unknown>(target: T) => T;
+export { injectable };

package/es/annotation/multi_inject.d.ts

@@ -0,0 +1,5 @@
+import { LazyServiceIdentifier } from '@inversifyjs/common';
+import { interfaces } from '../interfaces/interfaces';
+import { DecoratorTarget } from './decorator_utils';
+declare const multiInject: <T = unknown>(serviceIdentifier: interfaces.ServiceIdentifier<T> | LazyServiceIdentifier<T>) => (target: DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;
+export { multiInject };

package/es/annotation/named.d.ts

@@ -0,0 +1,2 @@
+declare function named(name: string | number | symbol): <T>(target: import("./decorator_utils").DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;
+export { named };

package/es/annotation/optional.d.ts

@@ -0,0 +1,2 @@
+declare function optional(): <T>(target: import("./decorator_utils").DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;
+export { optional };

package/es/annotation/post_construct.d.ts

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

package/es/annotation/pre_destroy.d.ts

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

package/es/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/es/annotation/tagged.d.ts

@@ -0,0 +1,2 @@
+declare function tagged(metadataKey: string | number | symbol, metadataValue: unknown): <T>(target: import("./decorator_utils").DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;
+export { tagged };

package/es/annotation/target_name.d.ts

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

package/es/annotation/unmanaged.d.ts

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

package/es/bindings/binding.d.ts

@@ -0,0 +1,20 @@
+import { interfaces } from '../interfaces/interfaces';
+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/es/bindings/binding_count.d.ts

@@ -0,0 +1,5 @@
+export declare enum BindingCount {
+    MultipleBindingsAvailable = 2,
+    NoBindingsAvailable = 0,
+    OnlyOneBindingAvailable = 1
+}

package/es/constants/error_msgs.d.ts

@@ -0,0 +1,30 @@
+export declare const DUPLICATED_INJECTABLE_DECORATOR: string;
+export declare const DUPLICATED_METADATA: string;
+export declare const NULL_ARGUMENT: string;
+export declare const KEY_NOT_FOUND: string;
+export declare const AMBIGUOUS_MATCH: string;
+export declare const CANNOT_UNBIND: string;
+export declare const NOT_REGISTERED: string;
+export declare const MISSING_INJECTABLE_ANNOTATION: string;
+export declare const UNDEFINED_INJECT_ANNOTATION: (name: string) => string;
+export declare const CIRCULAR_DEPENDENCY: string;
+export declare const INVALID_BINDING_TYPE: string;
+export declare const NO_MORE_SNAPSHOTS_AVAILABLE: string;
+export declare const INVALID_MIDDLEWARE_RETURN: string;
+export declare const INVALID_FUNCTION_BINDING: string;
+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: (name: string) => 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: string;
+export declare const MULTIPLE_POST_CONSTRUCT_METHODS: string;
+export declare const ASYNC_UNBIND_REQUIRED: string;
+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: string;

package/es/constants/literal_types.d.ts

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

package/es/constants/metadata_keys.d.ts

@@ -0,0 +1,13 @@
+export declare const NAMED_TAG: string;
+export declare const NAME_TAG: string;
+export declare const UNMANAGED_TAG: string;
+export declare const OPTIONAL_TAG: string;
+export declare const INJECT_TAG: string;
+export declare const MULTI_INJECT_TAG: string;
+export declare const TAGGED: string;
+export declare const TAGGED_PROP: string;
+export declare const PARAM_TYPES: string;
+export declare const DESIGN_PARAM_TYPES: string;
+export declare const POST_CONSTRUCT: string;
+export declare const PRE_DESTROY: string;
+export declare const NON_CUSTOM_TAG_KEYS: string[];

package/es/container/container.d.ts

@@ -0,0 +1,73 @@
+import { interfaces } from '../interfaces/interfaces';
+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 readonly _snapshots;
+    private _metadataReader;
+    private _moduleActivationStore;
+    constructor(containerOptions?: interfaces.ContainerOptions);
+    static merge(container1: interfaces.Container, container2: interfaces.Container, ...containers: interfaces.Container[]): interfaces.Container;
+    load(...modules: interfaces.ContainerModule[]): void;
+    loadAsync(...modules: interfaces.AsyncContainerModule[]): Promise<void>;
+    unload(...modules: interfaces.ContainerModuleBase[]): void;
+    unloadAsync(...modules: 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: 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>): T[];
+    getAllAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Promise<T[]>;
+    getAllTagged<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: unknown): T[];
+    getAllTaggedAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Promise<T[]>;
+    getAllNamed<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): T[];
+    getAllNamedAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): Promise<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/es/container/container_module.d.ts

@@ -0,0 +1,11 @@
+import { interfaces } from '../interfaces/interfaces';
+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/es/container/container_snapshot.d.ts

@@ -0,0 +1,10 @@
+import { interfaces } from '../interfaces/interfaces';
+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/es/container/lookup.d.ts

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

package/es/container/module_activation_store.d.ts

@@ -0,0 +1,10 @@
+import { interfaces } from '../interfaces/interfaces';
+export declare class ModuleActivationStore implements interfaces.ModuleActivationStore {
+    private readonly _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;
+}