diff options
Diffstat (limited to 'src/node_modules/inversify/dts')
45 files changed, 651 insertions, 0 deletions
diff --git a/src/node_modules/inversify/dts/annotation/decorator_utils.d.ts b/src/node_modules/inversify/dts/annotation/decorator_utils.d.ts new file mode 100644 index 0000000..2ec7769 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/annotation/inject.d.ts b/src/node_modules/inversify/dts/annotation/inject.d.ts new file mode 100644 index 0000000..86bc6f2 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/annotation/injectable.d.ts b/src/node_modules/inversify/dts/annotation/injectable.d.ts new file mode 100644 index 0000000..d679438 --- /dev/null +++ b/src/node_modules/inversify/dts/annotation/injectable.d.ts @@ -0,0 +1,2 @@ +declare function injectable(): (target: any) => any; +export { injectable }; diff --git a/src/node_modules/inversify/dts/annotation/multi_inject.d.ts b/src/node_modules/inversify/dts/annotation/multi_inject.d.ts new file mode 100644 index 0000000..362014f --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/annotation/named.d.ts b/src/node_modules/inversify/dts/annotation/named.d.ts new file mode 100644 index 0000000..9278743 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/annotation/optional.d.ts b/src/node_modules/inversify/dts/annotation/optional.d.ts new file mode 100644 index 0000000..ff6a04b --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/annotation/post_construct.d.ts b/src/node_modules/inversify/dts/annotation/post_construct.d.ts new file mode 100644 index 0000000..cba8035 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/annotation/tagged.d.ts b/src/node_modules/inversify/dts/annotation/tagged.d.ts new file mode 100644 index 0000000..34aed65 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/annotation/target_name.d.ts b/src/node_modules/inversify/dts/annotation/target_name.d.ts new file mode 100644 index 0000000..2edf0b9 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/annotation/unmanaged.d.ts b/src/node_modules/inversify/dts/annotation/unmanaged.d.ts new file mode 100644 index 0000000..4f7879f --- /dev/null +++ b/src/node_modules/inversify/dts/annotation/unmanaged.d.ts @@ -0,0 +1,2 @@ +declare function unmanaged(): (target: any, targetKey: string, index: number) => void; +export { unmanaged }; diff --git a/src/node_modules/inversify/dts/bindings/binding.d.ts b/src/node_modules/inversify/dts/bindings/binding.d.ts new file mode 100644 index 0000000..b065c21 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/bindings/binding_count.d.ts b/src/node_modules/inversify/dts/bindings/binding_count.d.ts new file mode 100644 index 0000000..9a872a3 --- /dev/null +++ b/src/node_modules/inversify/dts/bindings/binding_count.d.ts @@ -0,0 +1,6 @@ +declare const BindingCount: { + MultipleBindingsAvailable: number; + NoBindingsAvailable: number; + OnlyOneBindingAvailable: number; +}; +export { BindingCount }; diff --git a/src/node_modules/inversify/dts/constants/error_msgs.d.ts b/src/node_modules/inversify/dts/constants/error_msgs.d.ts new file mode 100644 index 0000000..81d3c82 --- /dev/null +++ b/src/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"; diff --git a/src/node_modules/inversify/dts/constants/literal_types.d.ts b/src/node_modules/inversify/dts/constants/literal_types.d.ts new file mode 100644 index 0000000..4fdb2ec --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/constants/metadata_keys.d.ts b/src/node_modules/inversify/dts/constants/metadata_keys.d.ts new file mode 100644 index 0000000..f6bfaac --- /dev/null +++ b/src/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"; diff --git a/src/node_modules/inversify/dts/container/container.d.ts b/src/node_modules/inversify/dts/container/container.d.ts new file mode 100644 index 0000000..5877ca3 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/container/container_module.d.ts b/src/node_modules/inversify/dts/container/container_module.d.ts new file mode 100644 index 0000000..92b8698 --- /dev/null +++ b/src/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); +} diff --git a/src/node_modules/inversify/dts/container/container_snapshot.d.ts b/src/node_modules/inversify/dts/container/container_snapshot.d.ts new file mode 100644 index 0000000..b5629a3 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/container/lookup.d.ts b/src/node_modules/inversify/dts/container/lookup.d.ts new file mode 100644 index 0000000..0a445f9 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/interfaces/interfaces.d.ts b/src/node_modules/inversify/dts/interfaces/interfaces.d.ts new file mode 100644 index 0000000..094f05a --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/inversify.d.ts b/src/node_modules/inversify/dts/inversify.d.ts new file mode 100644 index 0000000..5ead7f7 --- /dev/null +++ b/src/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"; diff --git a/src/node_modules/inversify/dts/planning/context.d.ts b/src/node_modules/inversify/dts/planning/context.d.ts new file mode 100644 index 0000000..5eabf26 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/planning/metadata.d.ts b/src/node_modules/inversify/dts/planning/metadata.d.ts new file mode 100644 index 0000000..e9435e0 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/planning/metadata_reader.d.ts b/src/node_modules/inversify/dts/planning/metadata_reader.d.ts new file mode 100644 index 0000000..e595789 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/planning/plan.d.ts b/src/node_modules/inversify/dts/planning/plan.d.ts new file mode 100644 index 0000000..400a81a --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/planning/planner.d.ts b/src/node_modules/inversify/dts/planning/planner.d.ts new file mode 100644 index 0000000..3459a4e --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/planning/queryable_string.d.ts b/src/node_modules/inversify/dts/planning/queryable_string.d.ts new file mode 100644 index 0000000..54abbff --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/planning/reflection_utils.d.ts b/src/node_modules/inversify/dts/planning/reflection_utils.d.ts new file mode 100644 index 0000000..0fc46f6 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/planning/request.d.ts b/src/node_modules/inversify/dts/planning/request.d.ts new file mode 100644 index 0000000..b01ba81 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/planning/target.d.ts b/src/node_modules/inversify/dts/planning/target.d.ts new file mode 100644 index 0000000..65ee18c --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/resolution/instantiation.d.ts b/src/node_modules/inversify/dts/resolution/instantiation.d.ts new file mode 100644 index 0000000..ad60187 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/resolution/resolver.d.ts b/src/node_modules/inversify/dts/resolution/resolver.d.ts new file mode 100644 index 0000000..2c5f1c0 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/syntax/binding_in_syntax.d.ts b/src/node_modules/inversify/dts/syntax/binding_in_syntax.d.ts new file mode 100644 index 0000000..67e154a --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/syntax/binding_in_when_on_syntax.d.ts b/src/node_modules/inversify/dts/syntax/binding_in_when_on_syntax.d.ts new file mode 100644 index 0000000..0f92f1b --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/syntax/binding_on_syntax.d.ts b/src/node_modules/inversify/dts/syntax/binding_on_syntax.d.ts new file mode 100644 index 0000000..54bf70a --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/syntax/binding_to_syntax.d.ts b/src/node_modules/inversify/dts/syntax/binding_to_syntax.d.ts new file mode 100644 index 0000000..78f994d --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/syntax/binding_when_on_syntax.d.ts b/src/node_modules/inversify/dts/syntax/binding_when_on_syntax.d.ts new file mode 100644 index 0000000..87e1093 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/syntax/binding_when_syntax.d.ts b/src/node_modules/inversify/dts/syntax/binding_when_syntax.d.ts new file mode 100644 index 0000000..7dab4a7 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/syntax/constraint_helpers.d.ts b/src/node_modules/inversify/dts/syntax/constraint_helpers.d.ts new file mode 100644 index 0000000..209f1e7 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/utils/binding_utils.d.ts b/src/node_modules/inversify/dts/utils/binding_utils.d.ts new file mode 100644 index 0000000..ff1d1f8 --- /dev/null +++ b/src/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; diff --git a/src/node_modules/inversify/dts/utils/exceptions.d.ts b/src/node_modules/inversify/dts/utils/exceptions.d.ts new file mode 100644 index 0000000..d1df327 --- /dev/null +++ b/src/node_modules/inversify/dts/utils/exceptions.d.ts @@ -0,0 +1 @@ +export declare function isStackOverflowExeption(error: Error): boolean; diff --git a/src/node_modules/inversify/dts/utils/guid.d.ts b/src/node_modules/inversify/dts/utils/guid.d.ts new file mode 100644 index 0000000..11a7975 --- /dev/null +++ b/src/node_modules/inversify/dts/utils/guid.d.ts @@ -0,0 +1,2 @@ +declare function guid(): string; +export { guid }; diff --git a/src/node_modules/inversify/dts/utils/id.d.ts b/src/node_modules/inversify/dts/utils/id.d.ts new file mode 100644 index 0000000..663904c --- /dev/null +++ b/src/node_modules/inversify/dts/utils/id.d.ts @@ -0,0 +1,2 @@ +declare function id(): number; +export { id }; diff --git a/src/node_modules/inversify/dts/utils/serialization.d.ts b/src/node_modules/inversify/dts/utils/serialization.d.ts new file mode 100644 index 0000000..fe20ec4 --- /dev/null +++ b/src/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 }; diff --git a/src/node_modules/inversify/dts/utils/template.d.ts b/src/node_modules/inversify/dts/utils/template.d.ts new file mode 100644 index 0000000..46e6d7e --- /dev/null +++ b/src/node_modules/inversify/dts/utils/template.d.ts @@ -0,0 +1 @@ +export declare function template(strings: TemplateStringsArray, ...keys: any[]): (...values: any[]) => string; |