SB-6.1-PRE

node_modules/inversify/dts/annotation/decorator_utils.d.ts

@@ -0,0 +1,5 @@
+import { interfaces } from "../interfaces/interfaces";
+declare function tagParameter(annotationTarget: any, propertyName: string, parameterIndex: number, metadata: interfaces.Metadata): void;
+declare function tagProperty(annotationTarget: any, propertyName: string, metadata: interfaces.Metadata): void;
+declare function decorate(decorator: (ClassDecorator | ParameterDecorator | MethodDecorator), target: any, parameterIndex?: number | string): void;
+export { decorate, tagParameter, tagProperty };

node_modules/inversify/dts/annotation/inject.d.ts

@@ -0,0 +1,9 @@
+import { interfaces } from "../interfaces/interfaces";
+export declare type ServiceIdentifierOrFunc = interfaces.ServiceIdentifier<any> | LazyServiceIdentifer;
+export declare class LazyServiceIdentifer<T = any> {
+    private _cb;
+    constructor(cb: () => interfaces.ServiceIdentifier<T>);
+    unwrap(): string | symbol | interfaces.Newable<T> | interfaces.Abstract<T>;
+}
+declare function inject(serviceIdentifier: ServiceIdentifierOrFunc): (target: any, targetKey: string, index?: number | undefined) => void;
+export { inject };

node_modules/inversify/dts/annotation/injectable.d.ts

@@ -0,0 +1,2 @@
+declare function injectable(): (target: any) => any;
+export { injectable };

node_modules/inversify/dts/annotation/multi_inject.d.ts

@@ -0,0 +1,3 @@
+import { interfaces } from "../interfaces/interfaces";
+declare function multiInject(serviceIdentifier: interfaces.ServiceIdentifier<any>): (target: any, targetKey: string, index?: number | undefined) => void;
+export { multiInject };

node_modules/inversify/dts/annotation/named.d.ts

@@ -0,0 +1,2 @@
+declare function named(name: string | number | symbol): (target: any, targetKey: string, index?: number | undefined) => void;
+export { named };

node_modules/inversify/dts/annotation/optional.d.ts

@@ -0,0 +1,2 @@
+declare function optional(): (target: any, targetKey: string, index?: number | undefined) => void;
+export { optional };

node_modules/inversify/dts/annotation/post_construct.d.ts

@@ -0,0 +1,2 @@
+declare function postConstruct(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export { postConstruct };

node_modules/inversify/dts/annotation/tagged.d.ts

@@ -0,0 +1,2 @@
+declare function tagged(metadataKey: string | number | symbol, metadataValue: any): (target: any, targetKey: string, index?: number | undefined) => void;
+export { tagged };

node_modules/inversify/dts/annotation/target_name.d.ts

@@ -0,0 +1,2 @@
+declare function targetName(name: string): (target: any, targetKey: string, index: number) => void;
+export { targetName };

node_modules/inversify/dts/annotation/unmanaged.d.ts

@@ -0,0 +1,2 @@
+declare function unmanaged(): (target: any, targetKey: string, index: number) => void;
+export { unmanaged };

node_modules/inversify/dts/bindings/binding.d.ts

@@ -0,0 +1,19 @@
+import { interfaces } from "../interfaces/interfaces";
+declare class Binding<T> implements interfaces.Binding<T> {
+    id: number;
+    moduleId: string;
+    activated: boolean;
+    serviceIdentifier: interfaces.ServiceIdentifier<T>;
+    implementationType: interfaces.Newable<T> | null;
+    cache: T | null;
+    dynamicValue: ((context: interfaces.Context) => T) | null;
+    scope: interfaces.BindingScope;
+    type: interfaces.BindingType;
+    factory: interfaces.FactoryCreator<T> | null;
+    provider: interfaces.ProviderCreator<T> | null;
+    constraint: (request: interfaces.Request) => boolean;
+    onActivation: ((context: interfaces.Context, injectable: T) => T) | null;
+    constructor(serviceIdentifier: interfaces.ServiceIdentifier<T>, scope: interfaces.BindingScope);
+    clone(): interfaces.Binding<T>;
+}
+export { Binding };

node_modules/inversify/dts/bindings/binding_count.d.ts

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

node_modules/inversify/dts/constants/error_msgs.d.ts

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

node_modules/inversify/dts/constants/literal_types.d.ts

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

node_modules/inversify/dts/constants/metadata_keys.d.ts

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

node_modules/inversify/dts/container/container.d.ts

@@ -0,0 +1,38 @@
+import { interfaces } from "../interfaces/interfaces";
+declare class Container implements interfaces.Container {
+    id: number;
+    parent: interfaces.Container | null;
+    readonly options: interfaces.ContainerOptions;
+    private _middleware;
+    private _bindingDictionary;
+    private _snapshots;
+    private _metadataReader;
+    static merge(container1: interfaces.Container, container2: interfaces.Container): interfaces.Container;
+    constructor(containerOptions?: interfaces.ContainerOptions);
+    load(...modules: interfaces.ContainerModule[]): void;
+    loadAsync(...modules: interfaces.AsyncContainerModule[]): Promise<void>;
+    unload(...modules: interfaces.ContainerModule[]): void;
+    bind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;
+    rebind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;
+    unbind(serviceIdentifier: interfaces.ServiceIdentifier<any>): void;
+    unbindAll(): void;
+    isBound(serviceIdentifier: interfaces.ServiceIdentifier<any>): boolean;
+    isBoundNamed(serviceIdentifier: interfaces.ServiceIdentifier<any>, named: string | number | symbol): boolean;
+    isBoundTagged(serviceIdentifier: interfaces.ServiceIdentifier<any>, key: string | number | symbol, value: any): boolean;
+    snapshot(): void;
+    restore(): void;
+    createChild(containerOptions?: interfaces.ContainerOptions): Container;
+    applyMiddleware(...middlewares: interfaces.Middleware[]): void;
+    applyCustomMetadataReader(metadataReader: interfaces.MetadataReader): void;
+    get<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T;
+    getTagged<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: any): T;
+    getNamed<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): T;
+    getAll<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T[];
+    getAllTagged<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: any): T[];
+    getAllNamed<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): T[];
+    resolve<T>(constructorFunction: interfaces.Newable<T>): T;
+    private _getContainerModuleHelpersFactory();
+    private _get<T>(avoidConstraints, isMultiInject, targetType, serviceIdentifier, key?, value?);
+    private _planAndResolve<T>();
+}
+export { Container };

node_modules/inversify/dts/container/container_module.d.ts

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

node_modules/inversify/dts/container/container_snapshot.d.ts

@@ -0,0 +1,7 @@
+import { interfaces } from "../interfaces/interfaces";
+declare class ContainerSnapshot implements interfaces.ContainerSnapshot {
+    bindings: interfaces.Lookup<interfaces.Binding<any>>;
+    middleware: interfaces.Next | null;
+    static of(bindings: interfaces.Lookup<interfaces.Binding<any>>, middleware: interfaces.Next | null): ContainerSnapshot;
+}
+export { ContainerSnapshot };

node_modules/inversify/dts/container/lookup.d.ts

@@ -0,0 +1,14 @@
+import { interfaces } from "../interfaces/interfaces";
+declare class Lookup<T extends interfaces.Clonable<T>> implements interfaces.Lookup<T> {
+    private _map;
+    constructor();
+    getMap(): Map<string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>, T[]>;
+    add(serviceIdentifier: interfaces.ServiceIdentifier<any>, value: T): void;
+    get(serviceIdentifier: interfaces.ServiceIdentifier<any>): T[];
+    remove(serviceIdentifier: interfaces.ServiceIdentifier<any>): void;
+    removeByCondition(condition: (item: T) => boolean): void;
+    hasKey(serviceIdentifier: interfaces.ServiceIdentifier<any>): boolean;
+    clone(): interfaces.Lookup<T>;
+    traverse(func: (key: interfaces.ServiceIdentifier<any>, value: T[]) => void): void;
+}
+export { Lookup };

node_modules/inversify/dts/interfaces/interfaces.d.ts

@@ -0,0 +1,239 @@
+declare namespace interfaces {
+    type BindingScope = "Singleton" | "Transient" | "Request";
+    type BindingType = "ConstantValue" | "Constructor" | "DynamicValue" | "Factory" | "Function" | "Instance" | "Invalid" | "Provider";
+    type TargetType = "ConstructorArgument" | "ClassProperty" | "Variable";
+    interface BindingScopeEnum {
+        Request: interfaces.BindingScope;
+        Singleton: interfaces.BindingScope;
+        Transient: interfaces.BindingScope;
+    }
+    interface BindingTypeEnum {
+        ConstantValue: interfaces.BindingType;
+        Constructor: interfaces.BindingType;
+        DynamicValue: interfaces.BindingType;
+        Factory: interfaces.BindingType;
+        Function: interfaces.BindingType;
+        Instance: interfaces.BindingType;
+        Invalid: interfaces.BindingType;
+        Provider: interfaces.BindingType;
+    }
+    interface TargetTypeEnum {
+        ConstructorArgument: interfaces.TargetType;
+        ClassProperty: interfaces.TargetType;
+        Variable: interfaces.TargetType;
+    }
+    interface Newable<T> {
+        new (...args: any[]): T;
+    }
+    interface Abstract<T> {
+        prototype: T;
+    }
+    type ServiceIdentifier<T> = (string | symbol | Newable<T> | Abstract<T>);
+    interface Clonable<T> {
+        clone(): T;
+    }
+    interface Binding<T> extends Clonable<Binding<T>> {
+        id: number;
+        moduleId: string;
+        activated: boolean;
+        serviceIdentifier: ServiceIdentifier<T>;
+        constraint: ConstraintFunction;
+        dynamicValue: ((context: interfaces.Context) => T) | null;
+        scope: BindingScope;
+        type: BindingType;
+        implementationType: Newable<T> | null;
+        factory: FactoryCreator<any> | null;
+        provider: ProviderCreator<any> | null;
+        onActivation: ((context: interfaces.Context, injectable: T) => T) | null;
+        cache: T | null;
+    }
+    type Factory<T> = (...args: any[]) => (((...args: any[]) => T) | T);
+    type FactoryCreator<T> = (context: Context) => Factory<T>;
+    type Provider<T> = (...args: any[]) => (((...args: any[]) => Promise<T>) | Promise<T>);
+    type ProviderCreator<T> = (context: Context) => Provider<T>;
+    interface NextArgs {
+        avoidConstraints: boolean;
+        contextInterceptor: ((contexts: Context) => Context);
+        isMultiInject: boolean;
+        targetType: TargetType;
+        serviceIdentifier: interfaces.ServiceIdentifier<any>;
+        key?: string | number | symbol;
+        value?: any;
+    }
+    type Next = (args: NextArgs) => (any | any[]);
+    type Middleware = (next: Next) => Next;
+    type ContextInterceptor = (context: interfaces.Context) => interfaces.Context;
+    interface Context {
+        id: number;
+        container: Container;
+        plan: Plan;
+        currentRequest: Request;
+        addPlan(plan: Plan): void;
+        setCurrentRequest(request: Request): void;
+    }
+    interface ReflectResult {
+        [key: string]: Metadata[];
+    }
+    interface Metadata {
+        key: string | number | symbol;
+        value: any;
+    }
+    interface Plan {
+        parentContext: Context;
+        rootRequest: Request;
+    }
+    interface QueryableString {
+        startsWith(searchString: string): boolean;
+        endsWith(searchString: string): boolean;
+        contains(searchString: string): boolean;
+        equals(compareString: string): boolean;
+        value(): string;
+    }
+    type ResolveRequestHandler = (request: interfaces.Request) => any;
+    type RequestScope = Map<any, any> | null;
+    interface Request {
+        id: number;
+        serviceIdentifier: ServiceIdentifier<any>;
+        parentContext: Context;
+        parentRequest: Request | null;
+        childRequests: Request[];
+        target: Target;
+        bindings: Binding<any>[];
+        requestScope: RequestScope;
+        addChildRequest(serviceIdentifier: ServiceIdentifier<any>, bindings: (Binding<any> | Binding<any>[]), target: Target): Request;
+    }
+    interface Target {
+        id: number;
+        serviceIdentifier: ServiceIdentifier<any>;
+        type: TargetType;
+        name: QueryableString;
+        metadata: Metadata[];
+        getNamedTag(): interfaces.Metadata | null;
+        getCustomTags(): interfaces.Metadata[] | null;
+        hasTag(key: string | number | symbol): boolean;
+        isArray(): boolean;
+        matchesArray(name: interfaces.ServiceIdentifier<any>): boolean;
+        isNamed(): boolean;
+        isTagged(): boolean;
+        isOptional(): boolean;
+        matchesNamedTag(name: string): boolean;
+        matchesTag(key: string | number | symbol): (value: any) => boolean;
+    }
+    interface ContainerOptions {
+        autoBindInjectable?: boolean;
+        defaultScope?: BindingScope;
+        skipBaseClassChecks?: boolean;
+    }
+    interface Container {
+        id: number;
+        parent: Container | null;
+        options: ContainerOptions;
+        bind<T>(serviceIdentifier: ServiceIdentifier<T>): BindingToSyntax<T>;
+        rebind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;
+        unbind(serviceIdentifier: ServiceIdentifier<any>): void;
+        unbindAll(): void;
+        isBound(serviceIdentifier: ServiceIdentifier<any>): boolean;
+        isBoundNamed(serviceIdentifier: ServiceIdentifier<any>, named: string | number | symbol): boolean;
+        isBoundTagged(serviceIdentifier: ServiceIdentifier<any>, key: string | number | symbol, value: any): boolean;
+        get<T>(serviceIdentifier: ServiceIdentifier<T>): T;
+        getNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): T;
+        getTagged<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: any): T;
+        getAll<T>(serviceIdentifier: ServiceIdentifier<T>): T[];
+        resolve<T>(constructorFunction: interfaces.Newable<T>): T;
+        load(...modules: ContainerModule[]): void;
+        loadAsync(...modules: AsyncContainerModule[]): Promise<void>;
+        unload(...modules: ContainerModule[]): void;
+        applyCustomMetadataReader(metadataReader: MetadataReader): void;
+        applyMiddleware(...middleware: Middleware[]): void;
+        snapshot(): void;
+        restore(): void;
+        createChild(): Container;
+    }
+    type Bind = <T>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;
+    type Rebind = <T>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;
+    type Unbind = <T>(serviceIdentifier: ServiceIdentifier<T>) => void;
+    type IsBound = <T>(serviceIdentifier: ServiceIdentifier<T>) => boolean;
+    interface ContainerModule {
+        id: number;
+        registry: ContainerModuleCallBack;
+    }
+    interface AsyncContainerModule {
+        id: number;
+        registry: AsyncContainerModuleCallBack;
+    }
+    type ContainerModuleCallBack = (bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind) => void;
+    type AsyncContainerModuleCallBack = (bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind) => Promise<void>;
+    interface ContainerSnapshot {
+        bindings: Lookup<Binding<any>>;
+        middleware: Next | null;
+    }
+    interface Lookup<T> extends Clonable<Lookup<T>> {
+        add(serviceIdentifier: ServiceIdentifier<any>, value: T): void;
+        getMap(): Map<interfaces.ServiceIdentifier<any>, T[]>;
+        get(serviceIdentifier: ServiceIdentifier<any>): T[];
+        remove(serviceIdentifier: interfaces.ServiceIdentifier<any>): void;
+        removeByCondition(condition: (item: T) => boolean): void;
+        hasKey(serviceIdentifier: ServiceIdentifier<any>): boolean;
+        clone(): Lookup<T>;
+        traverse(func: (key: interfaces.ServiceIdentifier<any>, value: T[]) => void): void;
+    }
+    interface BindingOnSyntax<T> {
+        onActivation(fn: (context: Context, injectable: T) => T): BindingWhenSyntax<T>;
+    }
+    interface BindingWhenSyntax<T> {
+        when(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
+        whenTargetNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenTargetIsDefault(): BindingOnSyntax<T>;
+        whenTargetTagged(tag: string | number | symbol, value: any): BindingOnSyntax<T>;
+        whenInjectedInto(parent: (Function | string)): BindingOnSyntax<T>;
+        whenParentNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenParentTagged(tag: string | number | symbol, value: any): BindingOnSyntax<T>;
+        whenAnyAncestorIs(ancestor: (Function | string)): BindingOnSyntax<T>;
+        whenNoAncestorIs(ancestor: (Function | string)): BindingOnSyntax<T>;
+        whenAnyAncestorNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenAnyAncestorTagged(tag: string | number | symbol, value: any): BindingOnSyntax<T>;
+        whenNoAncestorNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenNoAncestorTagged(tag: string | number | symbol, value: any): BindingOnSyntax<T>;
+        whenAnyAncestorMatches(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
+        whenNoAncestorMatches(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
+    }
+    interface BindingWhenOnSyntax<T> extends BindingWhenSyntax<T>, BindingOnSyntax<T> {
+    }
+    interface BindingInSyntax<T> {
+        inSingletonScope(): BindingWhenOnSyntax<T>;
+        inTransientScope(): BindingWhenOnSyntax<T>;
+        inRequestScope(): BindingWhenOnSyntax<T>;
+    }
+    interface BindingInWhenOnSyntax<T> extends BindingInSyntax<T>, BindingWhenOnSyntax<T> {
+    }
+    interface BindingToSyntax<T> {
+        to(constructor: {
+            new (...args: any[]): T;
+        }): BindingInWhenOnSyntax<T>;
+        toSelf(): BindingInWhenOnSyntax<T>;
+        toConstantValue(value: T): BindingWhenOnSyntax<T>;
+        toDynamicValue(func: (context: Context) => T): BindingInWhenOnSyntax<T>;
+        toConstructor<T2>(constructor: Newable<T2>): BindingWhenOnSyntax<T>;
+        toFactory<T2>(factory: FactoryCreator<T2>): BindingWhenOnSyntax<T>;
+        toFunction(func: T): BindingWhenOnSyntax<T>;
+        toAutoFactory<T2>(serviceIdentifier: ServiceIdentifier<T2>): BindingWhenOnSyntax<T>;
+        toProvider<T2>(provider: ProviderCreator<T2>): BindingWhenOnSyntax<T>;
+        toService(service: ServiceIdentifier<T>): void;
+    }
+    interface ConstraintFunction extends Function {
+        metaData?: Metadata;
+        (request: Request | null): boolean;
+    }
+    interface MetadataReader {
+        getConstructorMetadata(constructorFunc: Function): ConstructorMetadata;
+        getPropertiesMetadata(constructorFunc: Function): MetadataMap;
+    }
+    interface MetadataMap {
+        [propertyNameOrArgumentIndex: string]: Metadata[];
+    }
+    interface ConstructorMetadata {
+        compilerGeneratedMetadata: Function[] | undefined;
+        userGeneratedMetadata: MetadataMap;
+    }
+}
+export { interfaces };

node_modules/inversify/dts/inversify.d.ts

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

node_modules/inversify/dts/planning/context.d.ts

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

node_modules/inversify/dts/planning/metadata.d.ts

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

node_modules/inversify/dts/planning/metadata_reader.d.ts

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

node_modules/inversify/dts/planning/plan.d.ts

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

node_modules/inversify/dts/planning/planner.d.ts

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

node_modules/inversify/dts/planning/queryable_string.d.ts

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

node_modules/inversify/dts/planning/reflection_utils.d.ts

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

node_modules/inversify/dts/planning/request.d.ts

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

node_modules/inversify/dts/planning/target.d.ts

@@ -0,0 +1,21 @@
+import { interfaces } from "../interfaces/interfaces";
+import { Metadata } from "./metadata";
+declare class Target implements interfaces.Target {
+    id: number;
+    type: interfaces.TargetType;
+    serviceIdentifier: interfaces.ServiceIdentifier<any>;
+    name: interfaces.QueryableString;
+    metadata: Metadata[];
+    constructor(type: interfaces.TargetType, name: string, serviceIdentifier: interfaces.ServiceIdentifier<any>, namedOrTagged?: (string | Metadata));
+    hasTag(key: string): boolean;
+    isArray(): boolean;
+    matchesArray(name: interfaces.ServiceIdentifier<any>): boolean;
+    isNamed(): boolean;
+    isTagged(): boolean;
+    isOptional(): boolean;
+    getNamedTag(): interfaces.Metadata | null;
+    getCustomTags(): interfaces.Metadata[] | null;
+    matchesNamedTag(name: string): boolean;
+    matchesTag(key: string): (value: any) => boolean;
+}
+export { Target };

node_modules/inversify/dts/resolution/instantiation.d.ts

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

node_modules/inversify/dts/resolution/resolver.d.ts

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

node_modules/inversify/dts/syntax/binding_in_syntax.d.ts

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

node_modules/inversify/dts/syntax/binding_in_when_on_syntax.d.ts

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

node_modules/inversify/dts/syntax/binding_on_syntax.d.ts

@@ -0,0 +1,7 @@
+import { interfaces } from "../interfaces/interfaces";
+declare class BindingOnSyntax<T> implements interfaces.BindingOnSyntax<T> {
+    private _binding;
+    constructor(binding: interfaces.Binding<T>);
+    onActivation(handler: (context: interfaces.Context, injectable: T) => T): interfaces.BindingWhenSyntax<T>;
+}
+export { BindingOnSyntax };

node_modules/inversify/dts/syntax/binding_to_syntax.d.ts

@@ -0,0 +1,18 @@
+import { interfaces } from "../interfaces/interfaces";
+declare class BindingToSyntax<T> implements interfaces.BindingToSyntax<T> {
+    private _binding;
+    constructor(binding: interfaces.Binding<T>);
+    to(constructor: {
+        new (...args: any[]): T;
+    }): interfaces.BindingInWhenOnSyntax<T>;
+    toSelf(): interfaces.BindingInWhenOnSyntax<T>;
+    toConstantValue(value: T): interfaces.BindingWhenOnSyntax<T>;
+    toDynamicValue(func: (context: interfaces.Context) => T): interfaces.BindingInWhenOnSyntax<T>;
+    toConstructor<T2>(constructor: interfaces.Newable<T2>): interfaces.BindingWhenOnSyntax<T>;
+    toFactory<T2>(factory: interfaces.FactoryCreator<T2>): interfaces.BindingWhenOnSyntax<T>;
+    toFunction(func: T): interfaces.BindingWhenOnSyntax<T>;
+    toAutoFactory<T2>(serviceIdentifier: interfaces.ServiceIdentifier<T2>): interfaces.BindingWhenOnSyntax<T>;
+    toProvider<T2>(provider: interfaces.ProviderCreator<T2>): interfaces.BindingWhenOnSyntax<T>;
+    toService(service: string | symbol | interfaces.Newable<T> | interfaces.Abstract<T>): void;
+}
+export { BindingToSyntax };

node_modules/inversify/dts/syntax/binding_when_on_syntax.d.ts

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

node_modules/inversify/dts/syntax/binding_when_syntax.d.ts

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

node_modules/inversify/dts/syntax/constraint_helpers.d.ts

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

node_modules/inversify/dts/utils/binding_utils.d.ts

@@ -0,0 +1,2 @@
+import { interfaces } from "../inversify";
+export declare const multiBindToService: (container: interfaces.Container) => (service: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>) => (...types: (string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>)[]) => void;

node_modules/inversify/dts/utils/exceptions.d.ts

@@ -0,0 +1 @@
+export declare function isStackOverflowExeption(error: Error): boolean;

node_modules/inversify/dts/utils/guid.d.ts

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

node_modules/inversify/dts/utils/id.d.ts

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

node_modules/inversify/dts/utils/serialization.d.ts

@@ -0,0 +1,7 @@
+import { interfaces } from "../interfaces/interfaces";
+declare function getServiceIdentifierAsString(serviceIdentifier: interfaces.ServiceIdentifier<any>): string;
+declare function listRegisteredBindingsForServiceIdentifier(container: interfaces.Container, serviceIdentifier: string, getBindings: <T>(container: interfaces.Container, serviceIdentifier: interfaces.ServiceIdentifier<T>) => interfaces.Binding<T>[]): string;
+declare function circularDependencyToException(request: interfaces.Request): void;
+declare function listMetadataForTarget(serviceIdentifierString: string, target: interfaces.Target): string;
+declare function getFunctionName(v: any): string;
+export { getFunctionName, getServiceIdentifierAsString, listRegisteredBindingsForServiceIdentifier, listMetadataForTarget, circularDependencyToException };

node_modules/inversify/dts/utils/template.d.ts

@@ -0,0 +1 @@
+export declare function template(strings: TemplateStringsArray, ...keys: any[]): (...values: any[]) => string;