inversify 6.1.2-beta.1 → 6.1.3

package/es/interfaces/interfaces.d.ts

@@ -0,0 +1,269 @@
+import { Newable as CommonNewable, ServiceIdentifier as CommonServiceIdentifier } from '@inversifyjs/common';
+import { LegacyTarget } from '@inversifyjs/core';
+import { FactoryType } from '../utils/factory_type';
+declare namespace interfaces {
+    export type DynamicValue<T> = (context: interfaces.Context) => T | Promise<T>;
+    export type ContainerResolution<T> = T | Promise<T> | (T | Promise<T>)[];
+    type AsyncCallback<TCallback> = TCallback extends (...args: infer TArgs) => infer TResult ? (...args: TArgs) => Promise<TResult> : never;
+    export type BindingScope = 'Singleton' | 'Transient' | 'Request';
+    export type BindingType = 'ConstantValue' | 'Constructor' | 'DynamicValue' | 'Factory' | 'Function' | 'Instance' | 'Invalid' | 'Provider';
+    export type TargetType = 'ConstructorArgument' | 'ClassProperty' | 'Variable';
+    export interface BindingScopeEnum {
+        Request: interfaces.BindingScope;
+        Singleton: interfaces.BindingScope;
+        Transient: interfaces.BindingScope;
+    }
+    export interface BindingTypeEnum {
+        ConstantValue: interfaces.BindingType;
+        Constructor: interfaces.BindingType;
+        DynamicValue: interfaces.BindingType;
+        Factory: interfaces.BindingType;
+        Function: interfaces.BindingType;
+        Instance: interfaces.BindingType;
+        Invalid: interfaces.BindingType;
+        Provider: interfaces.BindingType;
+    }
+    export interface TargetTypeEnum {
+        ConstructorArgument: interfaces.TargetType;
+        ClassProperty: interfaces.TargetType;
+        Variable: interfaces.TargetType;
+    }
+    export type Newable<TInstance = unknown> = CommonNewable<TInstance>;
+    export type Instance<T> = T & Record<string, () => void>;
+    export interface Abstract<T> {
+        prototype: T;
+    }
+    export type ServiceIdentifier<T = unknown> = CommonServiceIdentifier<T>;
+    export interface Clonable<T> {
+        clone(): T;
+    }
+    export type BindingActivation<T = unknown> = (context: interfaces.Context, injectable: T) => T | Promise<T>;
+    export type BindingDeactivation<T = unknown> = (injectable: T) => void | Promise<void>;
+    export interface Binding<TActivated = unknown> extends Clonable<Binding<TActivated>> {
+        id: number;
+        moduleId: ContainerModuleBase['id'];
+        activated: boolean;
+        serviceIdentifier: ServiceIdentifier<TActivated>;
+        constraint: ConstraintFunction;
+        dynamicValue: DynamicValue<TActivated> | null;
+        scope: BindingScope;
+        type: BindingType;
+        implementationType: Newable<TActivated> | TActivated | null;
+        factory: FactoryCreator<unknown> | null;
+        provider: ProviderCreator<unknown> | null;
+        onActivation: BindingActivation<TActivated> | null;
+        onDeactivation: BindingDeactivation<TActivated> | null;
+        cache: null | TActivated | Promise<TActivated>;
+    }
+    export type SimpleFactory<T, U extends unknown[] = unknown[]> = (...args: U) => T;
+    export type MultiFactory<T, U extends unknown[] = unknown[], V extends unknown[] = unknown[]> = (...args: U) => SimpleFactory<T, V>;
+    export type Factory<T, U extends unknown[] = unknown[], V extends unknown[] = unknown[]> = SimpleFactory<T, U> | MultiFactory<T, U, V>;
+    export type FactoryCreator<T, U extends unknown[] = unknown[], V extends unknown[] = unknown[]> = (context: Context) => Factory<T, U, V>;
+    export type AutoNamedFactory<T> = SimpleFactory<T, [string]>;
+    export type AutoFactory<T> = SimpleFactory<T, []>;
+    export type FactoryTypeFunction<T = unknown> = (context: interfaces.Context) => T | Promise<T>;
+    export interface FactoryDetails {
+        factoryType: FactoryType;
+        factory: FactoryTypeFunction | null;
+    }
+    export type Provider<T> = (...args: any[]) => ((...args: any[]) => Promise<T>) | Promise<T>;
+    export type ProviderCreator<T> = (context: Context) => Provider<T>;
+    export interface NextArgs<T = unknown> {
+        avoidConstraints: boolean;
+        contextInterceptor: (contexts: Context) => Context;
+        isMultiInject: boolean;
+        targetType: TargetType;
+        serviceIdentifier: interfaces.ServiceIdentifier<T>;
+        key?: string | number | symbol | undefined;
+        value?: unknown;
+    }
+    export type Next = (args: NextArgs) => unknown | unknown[];
+    export type Middleware = (next: Next) => Next;
+    export type ContextInterceptor = (context: interfaces.Context) => interfaces.Context;
+    export interface Context {
+        id: number;
+        container: Container;
+        plan: Plan;
+        currentRequest: Request;
+        addPlan(plan: Plan): void;
+        setCurrentRequest(request: Request): void;
+    }
+    export type MetadataOrMetadataArray = Metadata | Metadata[];
+    export interface Metadata<TValue = unknown> {
+        key: string | number | symbol;
+        value: TValue;
+    }
+    export interface Plan {
+        parentContext: Context;
+        rootRequest: Request;
+    }
+    export interface QueryableString {
+        startsWith(searchString: string): boolean;
+        endsWith(searchString: string): boolean;
+        contains(searchString: string): boolean;
+        equals(compareString: string): boolean;
+        value(): string;
+    }
+    export type ResolveRequestHandler = (request: interfaces.Request) => unknown;
+    export type RequestScope = Map<unknown, unknown>;
+    export interface Request {
+        id: number;
+        serviceIdentifier: ServiceIdentifier;
+        parentContext: Context;
+        parentRequest: Request | null;
+        childRequests: Request[];
+        target: Target;
+        bindings: Binding<unknown>[];
+        requestScope: RequestScope | null;
+        addChildRequest(serviceIdentifier: ServiceIdentifier, bindings: Binding<unknown> | Binding<unknown>[], target: Target): Request;
+    }
+    export type Target = LegacyTarget;
+    export interface ContainerOptions {
+        autoBindInjectable?: boolean;
+        defaultScope?: BindingScope | undefined;
+        skipBaseClassChecks?: boolean;
+    }
+    export interface Container {
+        id: number;
+        parent: Container | null;
+        options: ContainerOptions;
+        bind<T>(serviceIdentifier: ServiceIdentifier<T>): BindingToSyntax<T>;
+        rebind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;
+        rebindAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Promise<interfaces.BindingToSyntax<T>>;
+        unbind(serviceIdentifier: ServiceIdentifier): void;
+        unbindAsync(serviceIdentifier: interfaces.ServiceIdentifier): Promise<void>;
+        unbindAll(): void;
+        unbindAllAsync(): Promise<void>;
+        isBound(serviceIdentifier: ServiceIdentifier): boolean;
+        isCurrentBound<T>(serviceIdentifier: ServiceIdentifier<T>): boolean;
+        isBoundNamed(serviceIdentifier: ServiceIdentifier, named: string | number | symbol): boolean;
+        isBoundTagged(serviceIdentifier: ServiceIdentifier, key: string | number | symbol, value: unknown): boolean;
+        get<T>(serviceIdentifier: ServiceIdentifier<T>): T;
+        getNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): T;
+        getTagged<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): T;
+        getAll<T>(serviceIdentifier: ServiceIdentifier<T>): T[];
+        getAllTagged<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): T[];
+        getAllNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): T[];
+        getAsync<T>(serviceIdentifier: ServiceIdentifier<T>): Promise<T>;
+        getNamedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): Promise<T>;
+        getTaggedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Promise<T>;
+        getAllAsync<T>(serviceIdentifier: ServiceIdentifier<T>): Promise<T[]>;
+        getAllTaggedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Promise<T[]>;
+        getAllNamedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): Promise<T[]>;
+        onActivation<T>(serviceIdentifier: ServiceIdentifier<T>, onActivation: BindingActivation<T>): void;
+        onDeactivation<T>(serviceIdentifier: ServiceIdentifier<T>, onDeactivation: BindingDeactivation<T>): void;
+        resolve<T>(constructorFunction: interfaces.Newable<T>): T;
+        load(...modules: ContainerModule[]): void;
+        loadAsync(...modules: AsyncContainerModule[]): Promise<void>;
+        unload(...modules: ContainerModuleBase[]): void;
+        unloadAsync(...modules: ContainerModuleBase[]): Promise<void>;
+        applyCustomMetadataReader(metadataReader: MetadataReader): void;
+        applyMiddleware(...middleware: Middleware[]): void;
+        snapshot(): void;
+        restore(): void;
+        createChild(): Container;
+    }
+    export type Bind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;
+    export type Rebind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;
+    export type Unbind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => void;
+    export type UnbindAsync = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => Promise<void>;
+    export type IsBound = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => boolean;
+    export interface ContainerModuleBase {
+        id: number;
+    }
+    export interface ContainerModule extends ContainerModuleBase {
+        registry: ContainerModuleCallBack;
+    }
+    export interface AsyncContainerModule extends ContainerModuleBase {
+        registry: AsyncContainerModuleCallBack;
+    }
+    export interface ModuleActivationHandlers {
+        onActivations: Lookup<BindingActivation<unknown>>;
+        onDeactivations: Lookup<BindingDeactivation<unknown>>;
+    }
+    export interface ModuleActivationStore extends Clonable<ModuleActivationStore> {
+        addDeactivation(moduleId: ContainerModuleBase['id'], serviceIdentifier: ServiceIdentifier<unknown>, onDeactivation: interfaces.BindingDeactivation<unknown>): void;
+        addActivation(moduleId: ContainerModuleBase['id'], serviceIdentifier: ServiceIdentifier<unknown>, onActivation: interfaces.BindingActivation<unknown>): void;
+        remove(moduleId: ContainerModuleBase['id']): ModuleActivationHandlers;
+    }
+    export type ContainerModuleCallBack = (bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind, unbindAsync: interfaces.UnbindAsync, onActivation: interfaces.Container['onActivation'], onDeactivation: interfaces.Container['onDeactivation']) => void;
+    export type AsyncContainerModuleCallBack = AsyncCallback<ContainerModuleCallBack>;
+    export interface ContainerSnapshot {
+        bindings: Lookup<Binding<unknown>>;
+        activations: Lookup<BindingActivation<unknown>>;
+        deactivations: Lookup<BindingDeactivation<unknown>>;
+        middleware: Next | null;
+        moduleActivationStore: interfaces.ModuleActivationStore;
+    }
+    export interface Lookup<T> extends Clonable<Lookup<T>> {
+        add(serviceIdentifier: ServiceIdentifier, value: T): void;
+        getMap(): Map<interfaces.ServiceIdentifier, T[]>;
+        get(serviceIdentifier: ServiceIdentifier): T[];
+        remove(serviceIdentifier: interfaces.ServiceIdentifier): void;
+        removeByCondition(condition: (item: T) => boolean): T[];
+        removeIntersection(lookup: interfaces.Lookup<T>): void;
+        hasKey(serviceIdentifier: ServiceIdentifier): boolean;
+        clone(): Lookup<T>;
+        traverse(func: (key: interfaces.ServiceIdentifier, value: T[]) => void): void;
+    }
+    export interface BindingOnSyntax<T> {
+        onActivation(fn: (context: Context, injectable: T) => T | Promise<T>): BindingWhenSyntax<T>;
+        onDeactivation(fn: (injectable: T) => void | Promise<void>): BindingWhenSyntax<T>;
+    }
+    export interface BindingWhenSyntax<T> {
+        when(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
+        whenTargetNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenTargetIsDefault(): BindingOnSyntax<T>;
+        whenTargetTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
+        whenInjectedInto(parent: NewableFunction | string): BindingOnSyntax<T>;
+        whenParentNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenParentTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
+        whenAnyAncestorIs(ancestor: NewableFunction | string): BindingOnSyntax<T>;
+        whenNoAncestorIs(ancestor: NewableFunction | string): BindingOnSyntax<T>;
+        whenAnyAncestorNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenAnyAncestorTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
+        whenNoAncestorNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenNoAncestorTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
+        whenAnyAncestorMatches(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
+        whenNoAncestorMatches(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
+    }
+    export interface BindingWhenOnSyntax<T> extends BindingWhenSyntax<T>, BindingOnSyntax<T> {
+    }
+    export interface BindingInSyntax<T> {
+        inSingletonScope(): BindingWhenOnSyntax<T>;
+        inTransientScope(): BindingWhenOnSyntax<T>;
+        inRequestScope(): BindingWhenOnSyntax<T>;
+    }
+    export interface BindingInWhenOnSyntax<T> extends BindingInSyntax<T>, BindingWhenOnSyntax<T> {
+    }
+    export interface BindingToSyntax<T> {
+        to(constructor: Newable<T>): BindingInWhenOnSyntax<T>;
+        toSelf(): BindingInWhenOnSyntax<T>;
+        toConstantValue(value: T): BindingWhenOnSyntax<T>;
+        toDynamicValue(func: DynamicValue<T>): BindingInWhenOnSyntax<T>;
+        toConstructor<T2>(constructor: Newable<T2>): BindingWhenOnSyntax<T>;
+        toFactory<T2, T3 extends unknown[] = unknown[], T4 extends unknown[] = unknown[]>(factory: FactoryCreator<T2, T3, T4>): BindingWhenOnSyntax<T>;
+        toFunction(func: T): BindingWhenOnSyntax<T>;
+        toAutoFactory<T2>(serviceIdentifier: ServiceIdentifier<T2>): BindingWhenOnSyntax<T>;
+        toAutoNamedFactory<T2>(serviceIdentifier: ServiceIdentifier<T2>): BindingWhenOnSyntax<T>;
+        toProvider<T2>(provider: ProviderCreator<T2>): BindingWhenOnSyntax<T>;
+        toService(service: ServiceIdentifier<T>): void;
+    }
+    export interface ConstraintFunction {
+        (request: Request | null): boolean;
+        metaData?: Metadata;
+    }
+    export interface MetadataReader {
+        getConstructorMetadata(constructorFunc: NewableFunction): ConstructorMetadata;
+        getPropertiesMetadata(constructorFunc: NewableFunction): MetadataMap;
+    }
+    export interface MetadataMap {
+        [propertyNameOrArgumentIndex: string | symbol]: Metadata[];
+    }
+    export interface ConstructorMetadata {
+        compilerGeneratedMetadata: NewableFunction[] | undefined;
+        userGeneratedMetadata: MetadataMap;
+    }
+    export {};
+}
+export type { interfaces };

package/es/inversify.d.ts

@@ -0,0 +1,24 @@
+import * as keys from './constants/metadata_keys';
+export { LazyServiceIdentifier } from '@inversifyjs/common';
+export declare const METADATA_KEY: typeof keys;
+export { Container } from './container/container';
+export { BindingScopeEnum, BindingTypeEnum, TargetTypeEnum, } from './constants/literal_types';
+export { AsyncContainerModule, ContainerModule, } from './container/container_module';
+export { createTaggedDecorator } from './annotation/decorator_utils';
+export { injectable } from './annotation/injectable';
+export { tagged } from './annotation/tagged';
+export { named } from './annotation/named';
+export { inject } from './annotation/inject';
+export { optional } from './annotation/optional';
+export { unmanaged } from './annotation/unmanaged';
+export { multiInject } from './annotation/multi_inject';
+export { targetName } from './annotation/target_name';
+export { postConstruct } from './annotation/post_construct';
+export { preDestroy } from './annotation/pre_destroy';
+export { MetadataReader } from './planning/metadata_reader';
+export { id } from './utils/id';
+export type { interfaces } from './interfaces/interfaces';
+export { decorate } from './annotation/decorator_utils';
+export { traverseAncerstors, taggedConstraint, namedConstraint, typeConstraint, } from './syntax/constraint_helpers';
+export { getServiceIdentifierAsString } from './utils/serialization';
+export { multiBindToService } from './utils/binding_utils';

package/es/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/es/planning/context.d.ts

@@ -0,0 +1,11 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class Context implements interfaces.Context {
+    id: number;
+    container: interfaces.Container;
+    plan: interfaces.Plan;
+    currentRequest: interfaces.Request;
+    constructor(container: interfaces.Container);
+    addPlan(plan: interfaces.Plan): void;
+    setCurrentRequest(currentRequest: interfaces.Request): void;
+}
+export { Context };

package/es/planning/metadata.d.ts

@@ -0,0 +1,8 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class Metadata implements interfaces.Metadata {
+    key: string | number | symbol;
+    value: unknown;
+    constructor(key: string | number | symbol, value: unknown);
+    toString(): string;
+}
+export { Metadata };

package/es/planning/metadata_reader.d.ts

@@ -0,0 +1,6 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class MetadataReader implements interfaces.MetadataReader {
+    getConstructorMetadata(constructorFunc: NewableFunction): interfaces.ConstructorMetadata;
+    getPropertiesMetadata(constructorFunc: NewableFunction): interfaces.MetadataMap;
+}
+export { MetadataReader };

package/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/utils/factory_type.d.ts

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

package/es/utils/id.d.ts

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

package/es/utils/js.d.ts

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

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

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

package/es6/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/es6/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/es6/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 };