inversify 6.1.4 → 6.1.5-beta.1

package/es/container/container_module.d.ts

@@ -1,11 +0,0 @@
-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_module.js

@@ -1,17 +0,0 @@
-import { id } from '../utils/id';
-var ContainerModule = (function () {
-    function ContainerModule(registry) {
-        this.id = id();
-        this.registry = registry;
-    }
-    return ContainerModule;
-}());
-export { ContainerModule };
-var AsyncContainerModule = (function () {
-    function AsyncContainerModule(registry) {
-        this.id = id();
-        this.registry = registry;
-    }
-    return AsyncContainerModule;
-}());
-export { AsyncContainerModule };

package/es/container/container_snapshot.js

@@ -1,15 +0,0 @@
-var ContainerSnapshot = (function () {
-    function ContainerSnapshot() {
-    }
-    ContainerSnapshot.of = function (bindings, middleware, activations, deactivations, moduleActivationStore) {
-        var snapshot = new ContainerSnapshot();
-        snapshot.bindings = bindings;
-        snapshot.middleware = middleware;
-        snapshot.deactivations = deactivations;
-        snapshot.activations = activations;
-        snapshot.moduleActivationStore = moduleActivationStore;
-        return snapshot;
-    };
-    return ContainerSnapshot;
-}());
-export { ContainerSnapshot };

package/es/container/lookup.js

@@ -1,105 +0,0 @@
-import * as ERROR_MSGS from '../constants/error_msgs';
-import { isClonable } from '../utils/clonable';
-var Lookup = (function () {
-    function Lookup() {
-        this._map = new Map();
-    }
-    Lookup.prototype.getMap = function () {
-        return this._map;
-    };
-    Lookup.prototype.add = function (serviceIdentifier, value) {
-        this._checkNonNulish(serviceIdentifier);
-        if (value === null || value === undefined) {
-            throw new Error(ERROR_MSGS.NULL_ARGUMENT);
-        }
-        var entry = this._map.get(serviceIdentifier);
-        if (entry !== undefined) {
-            entry.push(value);
-        }
-        else {
-            this._map.set(serviceIdentifier, [value]);
-        }
-    };
-    Lookup.prototype.get = function (serviceIdentifier) {
-        this._checkNonNulish(serviceIdentifier);
-        var entry = this._map.get(serviceIdentifier);
-        if (entry !== undefined) {
-            return entry;
-        }
-        else {
-            throw new Error(ERROR_MSGS.KEY_NOT_FOUND);
-        }
-    };
-    Lookup.prototype.remove = function (serviceIdentifier) {
-        this._checkNonNulish(serviceIdentifier);
-        if (!this._map.delete(serviceIdentifier)) {
-            throw new Error(ERROR_MSGS.KEY_NOT_FOUND);
-        }
-    };
-    Lookup.prototype.removeIntersection = function (lookup) {
-        var _this = this;
-        this.traverse(function (serviceIdentifier, value) {
-            var lookupActivations = lookup.hasKey(serviceIdentifier)
-                ? lookup.get(serviceIdentifier)
-                : undefined;
-            if (lookupActivations !== undefined) {
-                var filteredValues = value.filter(function (lookupValue) {
-                    return !lookupActivations.some(function (moduleActivation) { return lookupValue === moduleActivation; });
-                });
-                _this._setValue(serviceIdentifier, filteredValues);
-            }
-        });
-    };
-    Lookup.prototype.removeByCondition = function (condition) {
-        var _this = this;
-        var removals = [];
-        this._map.forEach(function (entries, key) {
-            var updatedEntries = [];
-            for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
-                var entry = entries_1[_i];
-                var remove = condition(entry);
-                if (remove) {
-                    removals.push(entry);
-                }
-                else {
-                    updatedEntries.push(entry);
-                }
-            }
-            _this._setValue(key, updatedEntries);
-        });
-        return removals;
-    };
-    Lookup.prototype.hasKey = function (serviceIdentifier) {
-        this._checkNonNulish(serviceIdentifier);
-        return this._map.has(serviceIdentifier);
-    };
-    Lookup.prototype.clone = function () {
-        var copy = new Lookup();
-        this._map.forEach(function (value, key) {
-            value.forEach(function (b) {
-                copy.add(key, isClonable(b) ? b.clone() : b);
-            });
-        });
-        return copy;
-    };
-    Lookup.prototype.traverse = function (func) {
-        this._map.forEach(function (value, key) {
-            func(key, value);
-        });
-    };
-    Lookup.prototype._checkNonNulish = function (value) {
-        if (value == null) {
-            throw new Error(ERROR_MSGS.NULL_ARGUMENT);
-        }
-    };
-    Lookup.prototype._setValue = function (serviceIdentifier, value) {
-        if (value.length > 0) {
-            this._map.set(serviceIdentifier, value);
-        }
-        else {
-            this._map.delete(serviceIdentifier);
-        }
-    };
-    return Lookup;
-}());
-export { Lookup };

package/es/container/module_activation_store.d.ts

@@ -1,10 +0,0 @@
-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;
-}

package/es/container/module_activation_store.js

@@ -1,47 +0,0 @@
-import { Lookup } from './lookup';
-var ModuleActivationStore = (function () {
-    function ModuleActivationStore() {
-        this._map = new Map();
-    }
-    ModuleActivationStore.prototype.remove = function (moduleId) {
-        var handlers = this._map.get(moduleId);
-        if (handlers === undefined) {
-            return this._getEmptyHandlersStore();
-        }
-        this._map.delete(moduleId);
-        return handlers;
-    };
-    ModuleActivationStore.prototype.addDeactivation = function (moduleId, serviceIdentifier, onDeactivation) {
-        this._getModuleActivationHandlers(moduleId).onDeactivations.add(serviceIdentifier, onDeactivation);
-    };
-    ModuleActivationStore.prototype.addActivation = function (moduleId, serviceIdentifier, onActivation) {
-        this._getModuleActivationHandlers(moduleId).onActivations.add(serviceIdentifier, onActivation);
-    };
-    ModuleActivationStore.prototype.clone = function () {
-        var clone = new ModuleActivationStore();
-        this._map.forEach(function (handlersStore, moduleId) {
-            clone._map.set(moduleId, {
-                onActivations: handlersStore.onActivations.clone(),
-                onDeactivations: handlersStore.onDeactivations.clone(),
-            });
-        });
-        return clone;
-    };
-    ModuleActivationStore.prototype._getModuleActivationHandlers = function (moduleId) {
-        var moduleActivationHandlers = this._map.get(moduleId);
-        if (moduleActivationHandlers === undefined) {
-            moduleActivationHandlers = this._getEmptyHandlersStore();
-            this._map.set(moduleId, moduleActivationHandlers);
-        }
-        return moduleActivationHandlers;
-    };
-    ModuleActivationStore.prototype._getEmptyHandlersStore = function () {
-        var handlersStore = {
-            onActivations: new Lookup(),
-            onDeactivations: new Lookup(),
-        };
-        return handlersStore;
-    };
-    return ModuleActivationStore;
-}());
-export { ModuleActivationStore };

package/es/interfaces/interfaces.d.ts

@@ -1,269 +0,0 @@
-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/interfaces/interfaces.js

@@ -1 +0,0 @@
-export {};

package/es/inversify.d.ts

@@ -1,24 +0,0 @@
-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';