inversify

  • Version 6.0.2
  • Published
  • 1.52 MB
  • No dependencies
  • MIT license

Install

npm i inversify
yarn add inversify
pnpm add inversify

Overview

A powerful and lightweight inversion of control container for JavaScript and Node.js apps powered by TypeScript.

Index

Variables

Functions

Classes

Namespaces

Variables

variable BindingScopeEnum

const BindingScopeEnum: interfaces.BindingScopeEnum;

    variable BindingTypeEnum

    const BindingTypeEnum: interfaces.BindingTypeEnum;

      variable METADATA_KEY

      const METADATA_KEY: typeof keys;

        variable TargetTypeEnum

        const TargetTypeEnum: interfaces.TargetTypeEnum;

          Functions

          function createTaggedDecorator

          createTaggedDecorator: (
          metadata: interfaces.MetadataOrMetadataArray
          ) => <T>(
          target: DecoratorTarget,
          targetKey?: string | symbol | undefined,
          indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>
          ) => void;

            function decorate

            decorate: (
            decorator: DecoratorTarget | ParameterDecorator | MethodDecorator,
            target: object,
            parameterIndexOrProperty?: number | string
            ) => void;

              function getServiceIdentifierAsString

              getServiceIdentifierAsString: (
              serviceIdentifier: interfaces.ServiceIdentifier
              ) => string;

                function id

                id: () => number;

                  function inject

                  inject: <T = unknown>(
                  serviceIdentifier: ServiceIdentifierOrFunc<T>
                  ) => (
                  target: import('./decorator_utils').DecoratorTarget<unknown>,
                  targetKey?: string | symbol | undefined,
                  indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>
                  ) => void;

                    function injectable

                    injectable: () => <T extends abstract new (...args: any) => unknown>(
                    target: T
                    ) => T;

                      function multiBindToService

                      multiBindToService: (
                      container: interfaces.Container
                      ) => (
                      service: interfaces.ServiceIdentifier
                      ) => (...types: interfaces.ServiceIdentifier[]) => void;

                        function multiInject

                        multiInject: <T = unknown>(
                        serviceIdentifier: ServiceIdentifierOrFunc<T>
                        ) => (
                        target: import('./decorator_utils').DecoratorTarget<unknown>,
                        targetKey?: string | symbol | undefined,
                        indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>
                        ) => void;

                          function named

                          named: (
                          name: string | number | symbol
                          ) => <T>(
                          target: import('./decorator_utils').DecoratorTarget<unknown>,
                          targetKey?: string | symbol | undefined,
                          indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>
                          ) => void;

                            function namedConstraint

                            namedConstraint: (value: unknown) => interfaces.ConstraintFunction;

                              function optional

                              optional: () => <T>(
                              target: import('./decorator_utils').DecoratorTarget<unknown>,
                              targetKey?: string | symbol | undefined,
                              indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>
                              ) => void;

                                function postConstruct

                                postConstruct: () => (
                                target: { constructor: NewableFunction },
                                propertyKey: string
                                ) => void;

                                  function preDestroy

                                  preDestroy: () => (
                                  target: { constructor: NewableFunction },
                                  propertyKey: string
                                  ) => void;

                                    function tagged

                                    tagged: <T>(
                                    metadataKey: string | number | symbol,
                                    metadataValue: unknown
                                    ) => <T_1>(
                                    target: import('./decorator_utils').DecoratorTarget<unknown>,
                                    targetKey?: string | symbol | undefined,
                                    indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T_1>
                                    ) => void;

                                      function taggedConstraint

                                      taggedConstraint: (
                                      key: string | number | symbol
                                      ) => (value: unknown) => interfaces.ConstraintFunction;

                                        function targetName

                                        targetName: (
                                        name: string
                                        ) => (target: DecoratorTarget, targetKey: string, index: number) => void;

                                          function traverseAncerstors

                                          traverseAncerstors: (
                                          request: interfaces.Request,
                                          constraint: interfaces.ConstraintFunction
                                          ) => boolean;

                                            function typeConstraint

                                            typeConstraint: (
                                            type: NewableFunction | string
                                            ) => (request: interfaces.Request | null) => boolean;

                                              function unmanaged

                                              unmanaged: () => (
                                              target: DecoratorTarget,
                                              targetKey: string | undefined,
                                              index: number
                                              ) => void;

                                                Classes

                                                class AsyncContainerModule

                                                class AsyncContainerModule implements interfaces.AsyncContainerModule {}

                                                  constructor

                                                  constructor(
                                                  registry: (
                                                  bind: interfaces.Bind,
                                                  unbind: interfaces.Unbind,
                                                  isBound: interfaces.IsBound,
                                                  rebind: interfaces.Rebind,
                                                  unbindAsync: interfaces.UnbindAsync,
                                                  onActivation: <T>(
                                                  serviceIdentifier: interfaces.ServiceIdentifier<T>,
                                                  onActivation: interfaces.BindingActivation<T>
                                                  ) => void,
                                                  onDeactivation: <T>(
                                                  serviceIdentifier: interfaces.ServiceIdentifier<T>,
                                                  onDeactivation: interfaces.BindingDeactivation<T>
                                                  ) => void
                                                  ) => Promise<void>
                                                  );

                                                    property id

                                                    id: number;

                                                      property registry

                                                      registry: (
                                                      bind: interfaces.Bind,
                                                      unbind: interfaces.Unbind,
                                                      isBound: interfaces.IsBound,
                                                      rebind: interfaces.Rebind,
                                                      unbindAsync: interfaces.UnbindAsync,
                                                      onActivation: <T>(
                                                      serviceIdentifier: interfaces.ServiceIdentifier<T>,
                                                      onActivation: interfaces.BindingActivation<T>
                                                      ) => void,
                                                      onDeactivation: <T>(
                                                      serviceIdentifier: interfaces.ServiceIdentifier<T>,
                                                      onDeactivation: interfaces.BindingDeactivation<T>
                                                      ) => void
                                                      ) => Promise<void>;

                                                        class Container

                                                        class Container implements interfaces.Container {}

                                                          constructor

                                                          constructor(containerOptions?: interfaces.ContainerOptions);

                                                            property id

                                                            id: number;

                                                              property options

                                                              readonly options: interfaces.ContainerOptions;

                                                                property parent

                                                                parent: interfaces.Container;

                                                                  method applyCustomMetadataReader

                                                                  applyCustomMetadataReader: (metadataReader: interfaces.MetadataReader) => void;

                                                                    method applyMiddleware

                                                                    applyMiddleware: (...middlewares: interfaces.Middleware[]) => void;

                                                                      method bind

                                                                      bind: <T>(
                                                                      serviceIdentifier: interfaces.ServiceIdentifier<T>
                                                                      ) => interfaces.BindingToSyntax<T>;

                                                                        method createChild

                                                                        createChild: (containerOptions?: interfaces.ContainerOptions) => Container;

                                                                          method get

                                                                          get: <T>(serviceIdentifier: interfaces.ServiceIdentifier<T>) => T;

                                                                            method getAll

                                                                            getAll: <T>(serviceIdentifier: interfaces.ServiceIdentifier<T>) => T[];

                                                                              method getAllAsync

                                                                              getAllAsync: <T>(
                                                                              serviceIdentifier: interfaces.ServiceIdentifier<T>
                                                                              ) => Promise<T[]>;

                                                                                method getAllNamed

                                                                                getAllNamed: <T>(
                                                                                serviceIdentifier: interfaces.ServiceIdentifier<T>,
                                                                                named: string | number | symbol
                                                                                ) => T[];

                                                                                  method getAllNamedAsync

                                                                                  getAllNamedAsync: <T>(
                                                                                  serviceIdentifier: interfaces.ServiceIdentifier<T>,
                                                                                  named: string | number | symbol
                                                                                  ) => Promise<T[]>;

                                                                                    method getAllTagged

                                                                                    getAllTagged: <T>(
                                                                                    serviceIdentifier: interfaces.ServiceIdentifier<T>,
                                                                                    key: string | number | symbol,
                                                                                    value: unknown
                                                                                    ) => T[];

                                                                                      method getAllTaggedAsync

                                                                                      getAllTaggedAsync: <T>(
                                                                                      serviceIdentifier: interfaces.ServiceIdentifier<T>,
                                                                                      key: string | number | symbol,
                                                                                      value: unknown
                                                                                      ) => Promise<T[]>;

                                                                                        method getAsync

                                                                                        getAsync: <T>(serviceIdentifier: interfaces.ServiceIdentifier<T>) => Promise<T>;

                                                                                          method getNamed

                                                                                          getNamed: <T>(
                                                                                          serviceIdentifier: interfaces.ServiceIdentifier<T>,
                                                                                          named: string | number | symbol
                                                                                          ) => T;

                                                                                            method getNamedAsync

                                                                                            getNamedAsync: <T>(
                                                                                            serviceIdentifier: interfaces.ServiceIdentifier<T>,
                                                                                            named: string | number | symbol
                                                                                            ) => Promise<T>;

                                                                                              method getTagged

                                                                                              getTagged: <T>(
                                                                                              serviceIdentifier: interfaces.ServiceIdentifier<T>,
                                                                                              key: string | number | symbol,
                                                                                              value: unknown
                                                                                              ) => T;

                                                                                                method getTaggedAsync

                                                                                                getTaggedAsync: <T>(
                                                                                                serviceIdentifier: interfaces.ServiceIdentifier<T>,
                                                                                                key: string | number | symbol,
                                                                                                value: unknown
                                                                                                ) => Promise<T>;

                                                                                                  method isBound

                                                                                                  isBound: (serviceIdentifier: interfaces.ServiceIdentifier<unknown>) => boolean;

                                                                                                    method isBoundNamed

                                                                                                    isBoundNamed: (
                                                                                                    serviceIdentifier: interfaces.ServiceIdentifier,
                                                                                                    named: string | number | symbol
                                                                                                    ) => boolean;

                                                                                                      method isBoundTagged

                                                                                                      isBoundTagged: (
                                                                                                      serviceIdentifier: interfaces.ServiceIdentifier,
                                                                                                      key: string | number | symbol,
                                                                                                      value: unknown
                                                                                                      ) => boolean;

                                                                                                        method isCurrentBound

                                                                                                        isCurrentBound: <T>(
                                                                                                        serviceIdentifier: interfaces.ServiceIdentifier<T>
                                                                                                        ) => boolean;

                                                                                                          method load

                                                                                                          load: (...modules: interfaces.ContainerModule[]) => void;

                                                                                                            method loadAsync

                                                                                                            loadAsync: (...modules: interfaces.AsyncContainerModule[]) => Promise<void>;

                                                                                                              method merge

                                                                                                              static merge: (
                                                                                                              container1: interfaces.Container,
                                                                                                              container2: interfaces.Container,
                                                                                                              ...containers: interfaces.Container[]
                                                                                                              ) => interfaces.Container;

                                                                                                                method onActivation

                                                                                                                onActivation: <T>(
                                                                                                                serviceIdentifier: interfaces.ServiceIdentifier<T>,
                                                                                                                onActivation: interfaces.BindingActivation<T>
                                                                                                                ) => void;

                                                                                                                  method onDeactivation

                                                                                                                  onDeactivation: <T>(
                                                                                                                  serviceIdentifier: interfaces.ServiceIdentifier<T>,
                                                                                                                  onDeactivation: interfaces.BindingDeactivation<T>
                                                                                                                  ) => void;

                                                                                                                    method rebind

                                                                                                                    rebind: <T>(
                                                                                                                    serviceIdentifier: interfaces.ServiceIdentifier<T>
                                                                                                                    ) => interfaces.BindingToSyntax<T>;

                                                                                                                      method rebindAsync

                                                                                                                      rebindAsync: <T>(
                                                                                                                      serviceIdentifier: interfaces.ServiceIdentifier<T>
                                                                                                                      ) => Promise<interfaces.BindingToSyntax<T>>;

                                                                                                                        method resolve

                                                                                                                        resolve: <T>(constructorFunction: interfaces.Newable<T>) => T;

                                                                                                                          method restore

                                                                                                                          restore: () => void;

                                                                                                                            method snapshot

                                                                                                                            snapshot: () => void;

                                                                                                                              method unbind

                                                                                                                              unbind: (serviceIdentifier: interfaces.ServiceIdentifier) => void;

                                                                                                                                method unbindAll

                                                                                                                                unbindAll: () => void;

                                                                                                                                  method unbindAllAsync

                                                                                                                                  unbindAllAsync: () => Promise<void>;

                                                                                                                                    method unbindAsync

                                                                                                                                    unbindAsync: (serviceIdentifier: interfaces.ServiceIdentifier) => Promise<void>;

                                                                                                                                      method unload

                                                                                                                                      unload: (...modules: interfaces.ContainerModuleBase[]) => void;

                                                                                                                                        method unloadAsync

                                                                                                                                        unloadAsync: (...modules: interfaces.ContainerModuleBase[]) => Promise<void>;

                                                                                                                                          class ContainerModule

                                                                                                                                          class ContainerModule implements interfaces.ContainerModule {}

                                                                                                                                            constructor

                                                                                                                                            constructor(registry: interfaces.ContainerModuleCallBack);

                                                                                                                                              property id

                                                                                                                                              id: number;

                                                                                                                                                property registry

                                                                                                                                                registry: interfaces.ContainerModuleCallBack;

                                                                                                                                                  class LazyServiceIdentifer

                                                                                                                                                  class LazyServiceIdentifier<T = unknown> {}

                                                                                                                                                    constructor

                                                                                                                                                    constructor(cb: () => interfaces.ServiceIdentifier<T>);

                                                                                                                                                      method unwrap

                                                                                                                                                      unwrap: () => interfaces.ServiceIdentifier<T>;

                                                                                                                                                        class LazyServiceIdentifier

                                                                                                                                                        class LazyServiceIdentifier<T = unknown> {}

                                                                                                                                                          constructor

                                                                                                                                                          constructor(cb: () => interfaces.ServiceIdentifier<T>);

                                                                                                                                                            method unwrap

                                                                                                                                                            unwrap: () => interfaces.ServiceIdentifier<T>;

                                                                                                                                                              class MetadataReader

                                                                                                                                                              class MetadataReader implements interfaces.MetadataReader {}

                                                                                                                                                                method getConstructorMetadata

                                                                                                                                                                getConstructorMetadata: (
                                                                                                                                                                constructorFunc: NewableFunction
                                                                                                                                                                ) => interfaces.ConstructorMetadata;

                                                                                                                                                                  method getPropertiesMetadata

                                                                                                                                                                  getPropertiesMetadata: (
                                                                                                                                                                  constructorFunc: NewableFunction
                                                                                                                                                                  ) => interfaces.MetadataMap;

                                                                                                                                                                    Namespaces

                                                                                                                                                                    namespace interfaces

                                                                                                                                                                    namespace interfaces {}

                                                                                                                                                                      interface Abstract

                                                                                                                                                                      interface Abstract<T> {}

                                                                                                                                                                        property prototype

                                                                                                                                                                        prototype: T;

                                                                                                                                                                          interface AsyncContainerModule

                                                                                                                                                                          interface AsyncContainerModule extends ContainerModuleBase {}

                                                                                                                                                                            property registry

                                                                                                                                                                            registry: AsyncContainerModuleCallBack;

                                                                                                                                                                              interface Binding

                                                                                                                                                                              interface Binding<TActivated = unknown> extends Clonable<Binding<TActivated>> {}

                                                                                                                                                                                property activated

                                                                                                                                                                                activated: boolean;

                                                                                                                                                                                  property cache

                                                                                                                                                                                  cache: null | TActivated | Promise<TActivated>;

                                                                                                                                                                                    property constraint

                                                                                                                                                                                    constraint: ConstraintFunction;

                                                                                                                                                                                      property dynamicValue

                                                                                                                                                                                      dynamicValue: DynamicValue<TActivated> | null;

                                                                                                                                                                                        property factory

                                                                                                                                                                                        factory: FactoryCreator<unknown> | null;

                                                                                                                                                                                          property id

                                                                                                                                                                                          id: number;

                                                                                                                                                                                            property implementationType

                                                                                                                                                                                            implementationType: Newable<TActivated> | TActivated | null;

                                                                                                                                                                                              property moduleId

                                                                                                                                                                                              moduleId: ContainerModuleBase['id'];

                                                                                                                                                                                                property onActivation

                                                                                                                                                                                                onActivation: BindingActivation<TActivated> | null;

                                                                                                                                                                                                  property onDeactivation

                                                                                                                                                                                                  onDeactivation: BindingDeactivation<TActivated> | null;

                                                                                                                                                                                                    property provider

                                                                                                                                                                                                    provider: ProviderCreator<unknown> | null;

                                                                                                                                                                                                      property scope

                                                                                                                                                                                                      scope: BindingScope;

                                                                                                                                                                                                        property serviceIdentifier

                                                                                                                                                                                                        serviceIdentifier: ServiceIdentifier<TActivated>;

                                                                                                                                                                                                          property type

                                                                                                                                                                                                          type: BindingType;

                                                                                                                                                                                                            interface BindingInSyntax

                                                                                                                                                                                                            interface BindingInSyntax<T> {}

                                                                                                                                                                                                              method inRequestScope

                                                                                                                                                                                                              inRequestScope: () => BindingWhenOnSyntax<T>;

                                                                                                                                                                                                                method inSingletonScope

                                                                                                                                                                                                                inSingletonScope: () => BindingWhenOnSyntax<T>;

                                                                                                                                                                                                                  method inTransientScope

                                                                                                                                                                                                                  inTransientScope: () => BindingWhenOnSyntax<T>;

                                                                                                                                                                                                                    interface BindingInWhenOnSyntax

                                                                                                                                                                                                                    interface BindingInWhenOnSyntax<T>
                                                                                                                                                                                                                    extends BindingInSyntax<T>,
                                                                                                                                                                                                                    BindingWhenOnSyntax<T> {}

                                                                                                                                                                                                                      interface BindingOnSyntax

                                                                                                                                                                                                                      interface BindingOnSyntax<T> {}

                                                                                                                                                                                                                        method onActivation

                                                                                                                                                                                                                        onActivation: (
                                                                                                                                                                                                                        fn: (context: Context, injectable: T) => T | Promise<T>
                                                                                                                                                                                                                        ) => BindingWhenSyntax<T>;

                                                                                                                                                                                                                          method onDeactivation

                                                                                                                                                                                                                          onDeactivation: (
                                                                                                                                                                                                                          fn: (injectable: T) => void | Promise<void>
                                                                                                                                                                                                                          ) => BindingWhenSyntax<T>;

                                                                                                                                                                                                                            interface BindingScopeEnum

                                                                                                                                                                                                                            interface BindingScopeEnum {}

                                                                                                                                                                                                                              property Request

                                                                                                                                                                                                                              Request: interfaces.BindingScope;

                                                                                                                                                                                                                                property Singleton

                                                                                                                                                                                                                                Singleton: interfaces.BindingScope;

                                                                                                                                                                                                                                  property Transient

                                                                                                                                                                                                                                  Transient: interfaces.BindingScope;

                                                                                                                                                                                                                                    interface BindingToSyntax

                                                                                                                                                                                                                                    interface BindingToSyntax<T> {}

                                                                                                                                                                                                                                      method to

                                                                                                                                                                                                                                      to: (constructor: Newable<T>) => BindingInWhenOnSyntax<T>;

                                                                                                                                                                                                                                        method toAutoFactory

                                                                                                                                                                                                                                        toAutoFactory: <T2>(
                                                                                                                                                                                                                                        serviceIdentifier: ServiceIdentifier<T2>
                                                                                                                                                                                                                                        ) => BindingWhenOnSyntax<T>;

                                                                                                                                                                                                                                          method toAutoNamedFactory

                                                                                                                                                                                                                                          toAutoNamedFactory: <T2>(
                                                                                                                                                                                                                                          serviceIdentifier: ServiceIdentifier<T2>
                                                                                                                                                                                                                                          ) => BindingWhenOnSyntax<T>;

                                                                                                                                                                                                                                            method toConstantValue

                                                                                                                                                                                                                                            toConstantValue: (value: T) => BindingWhenOnSyntax<T>;

                                                                                                                                                                                                                                              method toConstructor

                                                                                                                                                                                                                                              toConstructor: <T2>(constructor: Newable<T2>) => BindingWhenOnSyntax<T>;

                                                                                                                                                                                                                                                method toDynamicValue

                                                                                                                                                                                                                                                toDynamicValue: (func: DynamicValue<T>) => BindingInWhenOnSyntax<T>;

                                                                                                                                                                                                                                                  method toFactory

                                                                                                                                                                                                                                                  toFactory: <
                                                                                                                                                                                                                                                  T2,
                                                                                                                                                                                                                                                  T3 extends unknown[] = unknown[],
                                                                                                                                                                                                                                                  T4 extends unknown[] = unknown[]
                                                                                                                                                                                                                                                  >(
                                                                                                                                                                                                                                                  factory: FactoryCreator<T2, T3, T4>
                                                                                                                                                                                                                                                  ) => BindingWhenOnSyntax<T>;

                                                                                                                                                                                                                                                    method toFunction

                                                                                                                                                                                                                                                    toFunction: (func: T) => BindingWhenOnSyntax<T>;

                                                                                                                                                                                                                                                      method toProvider

                                                                                                                                                                                                                                                      toProvider: <T2>(provider: ProviderCreator<T2>) => BindingWhenOnSyntax<T>;

                                                                                                                                                                                                                                                        method toSelf

                                                                                                                                                                                                                                                        toSelf: () => BindingInWhenOnSyntax<T>;

                                                                                                                                                                                                                                                          method toService

                                                                                                                                                                                                                                                          toService: (service: ServiceIdentifier<T>) => void;

                                                                                                                                                                                                                                                            interface BindingTypeEnum

                                                                                                                                                                                                                                                            interface BindingTypeEnum {}

                                                                                                                                                                                                                                                              property ConstantValue

                                                                                                                                                                                                                                                              ConstantValue: interfaces.BindingType;

                                                                                                                                                                                                                                                                property Constructor

                                                                                                                                                                                                                                                                Constructor: interfaces.BindingType;

                                                                                                                                                                                                                                                                  property DynamicValue

                                                                                                                                                                                                                                                                  DynamicValue: interfaces.BindingType;

                                                                                                                                                                                                                                                                    property Factory

                                                                                                                                                                                                                                                                    Factory: interfaces.BindingType;

                                                                                                                                                                                                                                                                      property Function

                                                                                                                                                                                                                                                                      Function: interfaces.BindingType;

                                                                                                                                                                                                                                                                        property Instance

                                                                                                                                                                                                                                                                        Instance: interfaces.BindingType;

                                                                                                                                                                                                                                                                          property Invalid

                                                                                                                                                                                                                                                                          Invalid: interfaces.BindingType;

                                                                                                                                                                                                                                                                            property Provider

                                                                                                                                                                                                                                                                            Provider: interfaces.BindingType;

                                                                                                                                                                                                                                                                              interface BindingWhenOnSyntax

                                                                                                                                                                                                                                                                              interface BindingWhenOnSyntax<T> extends BindingWhenSyntax<T>, BindingOnSyntax<T> {}

                                                                                                                                                                                                                                                                                interface BindingWhenSyntax

                                                                                                                                                                                                                                                                                interface BindingWhenSyntax<T> {}

                                                                                                                                                                                                                                                                                  method when

                                                                                                                                                                                                                                                                                  when: (constraint: (request: Request) => boolean) => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                    method whenAnyAncestorIs

                                                                                                                                                                                                                                                                                    whenAnyAncestorIs: (ancestor: NewableFunction | string) => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                      method whenAnyAncestorMatches

                                                                                                                                                                                                                                                                                      whenAnyAncestorMatches: (
                                                                                                                                                                                                                                                                                      constraint: (request: Request) => boolean
                                                                                                                                                                                                                                                                                      ) => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                        method whenAnyAncestorNamed

                                                                                                                                                                                                                                                                                        whenAnyAncestorNamed: (name: string | number | symbol) => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                          method whenAnyAncestorTagged

                                                                                                                                                                                                                                                                                          whenAnyAncestorTagged: (
                                                                                                                                                                                                                                                                                          tag: string | number | symbol,
                                                                                                                                                                                                                                                                                          value: unknown
                                                                                                                                                                                                                                                                                          ) => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                            method whenInjectedInto

                                                                                                                                                                                                                                                                                            whenInjectedInto: (parent: NewableFunction | string) => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                              method whenNoAncestorIs

                                                                                                                                                                                                                                                                                              whenNoAncestorIs: (ancestor: NewableFunction | string) => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                                method whenNoAncestorMatches

                                                                                                                                                                                                                                                                                                whenNoAncestorMatches: (
                                                                                                                                                                                                                                                                                                constraint: (request: Request) => boolean
                                                                                                                                                                                                                                                                                                ) => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                                  method whenNoAncestorNamed

                                                                                                                                                                                                                                                                                                  whenNoAncestorNamed: (name: string | number | symbol) => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                                    method whenNoAncestorTagged

                                                                                                                                                                                                                                                                                                    whenNoAncestorTagged: (
                                                                                                                                                                                                                                                                                                    tag: string | number | symbol,
                                                                                                                                                                                                                                                                                                    value: unknown
                                                                                                                                                                                                                                                                                                    ) => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                                      method whenParentNamed

                                                                                                                                                                                                                                                                                                      whenParentNamed: (name: string | number | symbol) => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                                        method whenParentTagged

                                                                                                                                                                                                                                                                                                        whenParentTagged: (
                                                                                                                                                                                                                                                                                                        tag: string | number | symbol,
                                                                                                                                                                                                                                                                                                        value: unknown
                                                                                                                                                                                                                                                                                                        ) => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                                          method whenTargetIsDefault

                                                                                                                                                                                                                                                                                                          whenTargetIsDefault: () => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                                            method whenTargetNamed

                                                                                                                                                                                                                                                                                                            whenTargetNamed: (name: string | number | symbol) => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                                              method whenTargetTagged

                                                                                                                                                                                                                                                                                                              whenTargetTagged: (
                                                                                                                                                                                                                                                                                                              tag: string | number | symbol,
                                                                                                                                                                                                                                                                                                              value: unknown
                                                                                                                                                                                                                                                                                                              ) => BindingOnSyntax<T>;

                                                                                                                                                                                                                                                                                                                interface Clonable

                                                                                                                                                                                                                                                                                                                interface Clonable<T> {}

                                                                                                                                                                                                                                                                                                                  method clone

                                                                                                                                                                                                                                                                                                                  clone: () => T;

                                                                                                                                                                                                                                                                                                                    interface ConstraintFunction

                                                                                                                                                                                                                                                                                                                    interface ConstraintFunction {}

                                                                                                                                                                                                                                                                                                                      property metaData

                                                                                                                                                                                                                                                                                                                      metaData?: Metadata;

                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                        (request: Request | null): boolean;

                                                                                                                                                                                                                                                                                                                          interface ConstructorMetadata

                                                                                                                                                                                                                                                                                                                          interface ConstructorMetadata {}

                                                                                                                                                                                                                                                                                                                            property compilerGeneratedMetadata

                                                                                                                                                                                                                                                                                                                            compilerGeneratedMetadata: NewableFunction[] | undefined;

                                                                                                                                                                                                                                                                                                                              property userGeneratedMetadata

                                                                                                                                                                                                                                                                                                                              userGeneratedMetadata: MetadataMap;

                                                                                                                                                                                                                                                                                                                                interface Container

                                                                                                                                                                                                                                                                                                                                interface Container {}

                                                                                                                                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                                                                                                                                  id: number;

                                                                                                                                                                                                                                                                                                                                    property options

                                                                                                                                                                                                                                                                                                                                    options: ContainerOptions;

                                                                                                                                                                                                                                                                                                                                      property parent

                                                                                                                                                                                                                                                                                                                                      parent: Container | null;

                                                                                                                                                                                                                                                                                                                                        method applyCustomMetadataReader

                                                                                                                                                                                                                                                                                                                                        applyCustomMetadataReader: (metadataReader: MetadataReader) => void;

                                                                                                                                                                                                                                                                                                                                          method applyMiddleware

                                                                                                                                                                                                                                                                                                                                          applyMiddleware: (...middleware: Middleware[]) => void;

                                                                                                                                                                                                                                                                                                                                            method bind

                                                                                                                                                                                                                                                                                                                                            bind: <T>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;

                                                                                                                                                                                                                                                                                                                                              method createChild

                                                                                                                                                                                                                                                                                                                                              createChild: () => Container;

                                                                                                                                                                                                                                                                                                                                                method get

                                                                                                                                                                                                                                                                                                                                                get: <T>(serviceIdentifier: ServiceIdentifier<T>) => T;

                                                                                                                                                                                                                                                                                                                                                  method getAll

                                                                                                                                                                                                                                                                                                                                                  getAll: <T>(serviceIdentifier: ServiceIdentifier<T>) => T[];

                                                                                                                                                                                                                                                                                                                                                    method getAllAsync

                                                                                                                                                                                                                                                                                                                                                    getAllAsync: <T>(serviceIdentifier: ServiceIdentifier<T>) => Promise<T[]>;

                                                                                                                                                                                                                                                                                                                                                      method getAllNamed

                                                                                                                                                                                                                                                                                                                                                      getAllNamed: <T>(
                                                                                                                                                                                                                                                                                                                                                      serviceIdentifier: ServiceIdentifier<T>,
                                                                                                                                                                                                                                                                                                                                                      named: string | number | symbol
                                                                                                                                                                                                                                                                                                                                                      ) => T[];

                                                                                                                                                                                                                                                                                                                                                        method getAllNamedAsync

                                                                                                                                                                                                                                                                                                                                                        getAllNamedAsync: <T>(
                                                                                                                                                                                                                                                                                                                                                        serviceIdentifier: ServiceIdentifier<T>,
                                                                                                                                                                                                                                                                                                                                                        named: string | number | symbol
                                                                                                                                                                                                                                                                                                                                                        ) => Promise<T[]>;

                                                                                                                                                                                                                                                                                                                                                          method getAllTagged

                                                                                                                                                                                                                                                                                                                                                          getAllTagged: <T>(
                                                                                                                                                                                                                                                                                                                                                          serviceIdentifier: ServiceIdentifier<T>,
                                                                                                                                                                                                                                                                                                                                                          key: string | number | symbol,
                                                                                                                                                                                                                                                                                                                                                          value: unknown
                                                                                                                                                                                                                                                                                                                                                          ) => T[];

                                                                                                                                                                                                                                                                                                                                                            method getAllTaggedAsync

                                                                                                                                                                                                                                                                                                                                                            getAllTaggedAsync: <T>(
                                                                                                                                                                                                                                                                                                                                                            serviceIdentifier: ServiceIdentifier<T>,
                                                                                                                                                                                                                                                                                                                                                            key: string | number | symbol,
                                                                                                                                                                                                                                                                                                                                                            value: unknown
                                                                                                                                                                                                                                                                                                                                                            ) => Promise<T[]>;

                                                                                                                                                                                                                                                                                                                                                              method getAsync

                                                                                                                                                                                                                                                                                                                                                              getAsync: <T>(serviceIdentifier: ServiceIdentifier<T>) => Promise<T>;

                                                                                                                                                                                                                                                                                                                                                                method getNamed

                                                                                                                                                                                                                                                                                                                                                                getNamed: <T>(
                                                                                                                                                                                                                                                                                                                                                                serviceIdentifier: ServiceIdentifier<T>,
                                                                                                                                                                                                                                                                                                                                                                named: string | number | symbol
                                                                                                                                                                                                                                                                                                                                                                ) => T;

                                                                                                                                                                                                                                                                                                                                                                  method getNamedAsync

                                                                                                                                                                                                                                                                                                                                                                  getNamedAsync: <T>(
                                                                                                                                                                                                                                                                                                                                                                  serviceIdentifier: ServiceIdentifier<T>,
                                                                                                                                                                                                                                                                                                                                                                  named: string | number | symbol
                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<T>;

                                                                                                                                                                                                                                                                                                                                                                    method getTagged

                                                                                                                                                                                                                                                                                                                                                                    getTagged: <T>(
                                                                                                                                                                                                                                                                                                                                                                    serviceIdentifier: ServiceIdentifier<T>,
                                                                                                                                                                                                                                                                                                                                                                    key: string | number | symbol,
                                                                                                                                                                                                                                                                                                                                                                    value: unknown
                                                                                                                                                                                                                                                                                                                                                                    ) => T;

                                                                                                                                                                                                                                                                                                                                                                      method getTaggedAsync

                                                                                                                                                                                                                                                                                                                                                                      getTaggedAsync: <T>(
                                                                                                                                                                                                                                                                                                                                                                      serviceIdentifier: ServiceIdentifier<T>,
                                                                                                                                                                                                                                                                                                                                                                      key: string | number | symbol,
                                                                                                                                                                                                                                                                                                                                                                      value: unknown
                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<T>;

                                                                                                                                                                                                                                                                                                                                                                        method isBound

                                                                                                                                                                                                                                                                                                                                                                        isBound: (serviceIdentifier: ServiceIdentifier) => boolean;

                                                                                                                                                                                                                                                                                                                                                                          method isBoundNamed

                                                                                                                                                                                                                                                                                                                                                                          isBoundNamed: (
                                                                                                                                                                                                                                                                                                                                                                          serviceIdentifier: ServiceIdentifier,
                                                                                                                                                                                                                                                                                                                                                                          named: string | number | symbol
                                                                                                                                                                                                                                                                                                                                                                          ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                            method isBoundTagged

                                                                                                                                                                                                                                                                                                                                                                            isBoundTagged: (
                                                                                                                                                                                                                                                                                                                                                                            serviceIdentifier: ServiceIdentifier,
                                                                                                                                                                                                                                                                                                                                                                            key: string | number | symbol,
                                                                                                                                                                                                                                                                                                                                                                            value: unknown
                                                                                                                                                                                                                                                                                                                                                                            ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                              method isCurrentBound

                                                                                                                                                                                                                                                                                                                                                                              isCurrentBound: <T>(serviceIdentifier: ServiceIdentifier<T>) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                method load

                                                                                                                                                                                                                                                                                                                                                                                load: (...modules: ContainerModule[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                  method loadAsync

                                                                                                                                                                                                                                                                                                                                                                                  loadAsync: (...modules: AsyncContainerModule[]) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                    method onActivation

                                                                                                                                                                                                                                                                                                                                                                                    onActivation: <T>(
                                                                                                                                                                                                                                                                                                                                                                                    serviceIdentifier: ServiceIdentifier<T>,
                                                                                                                                                                                                                                                                                                                                                                                    onActivation: BindingActivation<T>
                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                      method onDeactivation

                                                                                                                                                                                                                                                                                                                                                                                      onDeactivation: <T>(
                                                                                                                                                                                                                                                                                                                                                                                      serviceIdentifier: ServiceIdentifier<T>,
                                                                                                                                                                                                                                                                                                                                                                                      onDeactivation: BindingDeactivation<T>
                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                        method rebind

                                                                                                                                                                                                                                                                                                                                                                                        rebind: <T>(
                                                                                                                                                                                                                                                                                                                                                                                        serviceIdentifier: interfaces.ServiceIdentifier<T>
                                                                                                                                                                                                                                                                                                                                                                                        ) => interfaces.BindingToSyntax<T>;

                                                                                                                                                                                                                                                                                                                                                                                          method rebindAsync

                                                                                                                                                                                                                                                                                                                                                                                          rebindAsync: <T>(
                                                                                                                                                                                                                                                                                                                                                                                          serviceIdentifier: interfaces.ServiceIdentifier<T>
                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<interfaces.BindingToSyntax<T>>;

                                                                                                                                                                                                                                                                                                                                                                                            method resolve

                                                                                                                                                                                                                                                                                                                                                                                            resolve: <T>(constructorFunction: interfaces.Newable<T>) => T;

                                                                                                                                                                                                                                                                                                                                                                                              method restore

                                                                                                                                                                                                                                                                                                                                                                                              restore: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                method snapshot

                                                                                                                                                                                                                                                                                                                                                                                                snapshot: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                  method unbind

                                                                                                                                                                                                                                                                                                                                                                                                  unbind: (serviceIdentifier: ServiceIdentifier) => void;

                                                                                                                                                                                                                                                                                                                                                                                                    method unbindAll

                                                                                                                                                                                                                                                                                                                                                                                                    unbindAll: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                      method unbindAllAsync

                                                                                                                                                                                                                                                                                                                                                                                                      unbindAllAsync: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                        method unbindAsync

                                                                                                                                                                                                                                                                                                                                                                                                        unbindAsync: (serviceIdentifier: interfaces.ServiceIdentifier) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                          method unload

                                                                                                                                                                                                                                                                                                                                                                                                          unload: (...modules: ContainerModuleBase[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                            method unloadAsync

                                                                                                                                                                                                                                                                                                                                                                                                            unloadAsync: (...modules: ContainerModuleBase[]) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                              interface ContainerModule

                                                                                                                                                                                                                                                                                                                                                                                                              interface ContainerModule extends ContainerModuleBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                property registry

                                                                                                                                                                                                                                                                                                                                                                                                                registry: ContainerModuleCallBack;

                                                                                                                                                                                                                                                                                                                                                                                                                  interface ContainerModuleBase

                                                                                                                                                                                                                                                                                                                                                                                                                  interface ContainerModuleBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                                                                                                                                                                    id: number;

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ContainerOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ContainerOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                        property autoBindInjectable

                                                                                                                                                                                                                                                                                                                                                                                                                        autoBindInjectable?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                          property defaultScope

                                                                                                                                                                                                                                                                                                                                                                                                                          defaultScope?: BindingScope | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                            property skipBaseClassChecks

                                                                                                                                                                                                                                                                                                                                                                                                                            skipBaseClassChecks?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                              interface ContainerSnapshot

                                                                                                                                                                                                                                                                                                                                                                                                                              interface ContainerSnapshot {}

                                                                                                                                                                                                                                                                                                                                                                                                                                property activations

                                                                                                                                                                                                                                                                                                                                                                                                                                activations: Lookup<BindingActivation<unknown>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property bindings

                                                                                                                                                                                                                                                                                                                                                                                                                                  bindings: Lookup<Binding<unknown>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property deactivations

                                                                                                                                                                                                                                                                                                                                                                                                                                    deactivations: Lookup<BindingDeactivation<unknown>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property middleware

                                                                                                                                                                                                                                                                                                                                                                                                                                      middleware: Next | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property moduleActivationStore

                                                                                                                                                                                                                                                                                                                                                                                                                                        moduleActivationStore: interfaces.ModuleActivationStore;

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Context

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Context {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            property container

                                                                                                                                                                                                                                                                                                                                                                                                                                            container: Container;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property currentRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                              currentRequest: Request;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                id: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property plan

                                                                                                                                                                                                                                                                                                                                                                                                                                                  plan: Plan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method addPlan

                                                                                                                                                                                                                                                                                                                                                                                                                                                    addPlan: (plan: Plan) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setCurrentRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                      setCurrentRequest: (request: Request) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface FactoryDetails

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface FactoryDetails {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property factory

                                                                                                                                                                                                                                                                                                                                                                                                                                                          factory: FactoryTypeFunction | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property factoryType

                                                                                                                                                                                                                                                                                                                                                                                                                                                            factoryType: FactoryType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Lookup

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Lookup<T> extends Clonable<Lookup<T>> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                add: (serviceIdentifier: ServiceIdentifier, value: T) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method clone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  clone: () => Lookup<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    get: (serviceIdentifier: ServiceIdentifier) => T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getMap: () => Map<interfaces.ServiceIdentifier, T[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method hasKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hasKey: (serviceIdentifier: ServiceIdentifier) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          remove: (serviceIdentifier: interfaces.ServiceIdentifier) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method removeByCondition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            removeByCondition: (condition: (item: T) => boolean) => T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method removeIntersection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              removeIntersection: (lookup: interfaces.Lookup<T>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method traverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                traverse: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func: (key: interfaces.ServiceIdentifier, value: T[]) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Metadata<TValue = unknown> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key: string | number | symbol;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: TValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MetadataMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MetadataMap {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [propertyNameOrArgumentIndex: string | symbol]: Metadata[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MetadataReader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MetadataReader {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getConstructorMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getConstructorMetadata: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructorFunc: NewableFunction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => ConstructorMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getPropertiesMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getPropertiesMetadata: (constructorFunc: NewableFunction) => MetadataMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ModuleActivationHandlers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ModuleActivationHandlers {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onActivations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onActivations: Lookup<BindingActivation<unknown>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onDeactivations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDeactivations: Lookup<BindingDeactivation<unknown>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ModuleActivationStore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ModuleActivationStore extends Clonable<ModuleActivationStore> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method addActivation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          addActivation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          moduleId: ContainerModuleBase['id'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          serviceIdentifier: ServiceIdentifier<unknown>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onActivation: interfaces.BindingActivation<unknown>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method addDeactivation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            addDeactivation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            moduleId: ContainerModuleBase['id'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            serviceIdentifier: ServiceIdentifier<unknown>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onDeactivation: interfaces.BindingDeactivation<unknown>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              remove: (moduleId: ContainerModuleBase['id']) => ModuleActivationHandlers;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface NextArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface NextArgs<T = unknown> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property avoidConstraints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  avoidConstraints: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property contextInterceptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    contextInterceptor: (contexts: Context) => Context;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isMultiInject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isMultiInject: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        key?: string | number | symbol | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property serviceIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          serviceIdentifier: interfaces.ServiceIdentifier<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property targetType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            targetType: TargetType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value?: unknown;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Plan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Plan {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property parentContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parentContext: Context;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property rootRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rootRequest: Request;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface QueryableString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface QueryableString {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method contains

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        contains: (searchString: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method endsWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          endsWith: (searchString: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method equals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            equals: (compareString: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method startsWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              startsWith: (searchString: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Request {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property bindings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bindings: Binding<unknown>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property childRequests

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      childRequests: Request[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        id: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property parentContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parentContext: Context;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property parentRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parentRequest: Request | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property requestScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              requestScope: RequestScope | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property serviceIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serviceIdentifier: ServiceIdentifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  target: Target;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method addChildRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    addChildRequest: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    serviceIdentifier: ServiceIdentifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bindings: Binding<unknown> | Binding<unknown>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    target: Target
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Request;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Target {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        id: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property identifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          identifier: string | symbol;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            metadata: Metadata[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: QueryableString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property serviceIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serviceIdentifier: ServiceIdentifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: TargetType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getCustomTags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getCustomTags: () => interfaces.Metadata[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getNamedTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getNamedTag: () => interfaces.Metadata<string> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method hasTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hasTag: (key: string | number | symbol) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isArray: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isNamed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isNamed: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isOptional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isOptional: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isTagged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isTagged: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method matchesArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  matchesArray: (name: interfaces.ServiceIdentifier) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method matchesNamedTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    matchesNamedTag: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method matchesTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      matchesTag: (key: string | number | symbol) => (value: unknown) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TargetTypeEnum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TargetTypeEnum {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ClassProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ClassProperty: interfaces.TargetType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ConstructorArgument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ConstructorArgument: interfaces.TargetType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Variable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Variable: interfaces.TargetType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type AsyncContainerModuleCallBack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type AsyncContainerModuleCallBack = AsyncCallback<ContainerModuleCallBack>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type AutoFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type AutoFactory<T> = SimpleFactory<T, []>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AutoNamedFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AutoNamedFactory<T> = SimpleFactory<T, [string]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Bind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Bind = <T = unknown>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serviceIdentifier: ServiceIdentifier<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => BindingToSyntax<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type BindingActivation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type BindingActivation<T = unknown> = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        context: interfaces.Context,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        injectable: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => T | Promise<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type BindingDeactivation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type BindingDeactivation<T = unknown> = (injectable: T) => void | Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type BindingScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type BindingScope = 'Singleton' | 'Transient' | 'Request';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type BindingType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type BindingType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'ConstantValue'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'Constructor'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'DynamicValue'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'Factory'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'Function'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'Instance'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'Invalid'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'Provider';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ContainerModuleCallBack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ContainerResolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ContainerResolution<T> = T | Promise<T> | (T | Promise<T>)[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ContextInterceptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ContextInterceptor = (context: interfaces.Context) => interfaces.Context;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DynamicValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DynamicValue<T> = (context: interfaces.Context) => T | Promise<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Factory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Factory<T, U extends unknown[] = unknown[], V extends unknown[] = unknown[]> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | SimpleFactory<T, U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | MultiFactory<T, U, V>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FactoryCreator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FactoryCreator<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          U extends unknown[] = unknown[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          V extends unknown[] = unknown[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          > = (context: Context) => Factory<T, U, V>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FactoryTypeFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FactoryTypeFunction<T = unknown> = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            context: interfaces.Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => T | Promise<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Instance<T> = T & Record<string, () => void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type IsBound

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type IsBound = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MetadataOrMetadataArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MetadataOrMetadataArray = Metadata | Metadata[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Middleware

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Middleware = (next: Next) => Next;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MultiFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MultiFactory<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      U extends unknown[] = unknown[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      V extends unknown[] = unknown[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > = (...args: U) => SimpleFactory<T, V>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Newable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Newable<T> = new (...args: any[]) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Next

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Next = (args: NextArgs) => unknown | unknown[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Provider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Provider<T> = (...args: any[]) => ((...args: any[]) => Promise<T>) | Promise<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ProviderCreator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ProviderCreator<T> = (context: Context) => Provider<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Rebind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Rebind = <T = unknown>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serviceIdentifier: ServiceIdentifier<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => BindingToSyntax<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RequestScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RequestScope = Map<unknown, unknown>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ResolveRequestHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ResolveRequestHandler = (request: interfaces.Request) => unknown;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ServiceIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ServiceIdentifier<T = unknown> = string | symbol | Newable<T> | Abstract<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SimpleFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SimpleFactory<T, U extends unknown[] = unknown[]> = (...args: U) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TargetType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TargetType = 'ConstructorArgument' | 'ClassProperty' | 'Variable';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Unbind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Unbind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UnbindAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UnbindAsync = <T = unknown>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              serviceIdentifier: ServiceIdentifier<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Package Files (22)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dev Dependencies (14)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/inversify.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/inversify)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <a href="https://www.jsdocs.io/package/inversify"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>