@expressots/core 2.16.2 → 3.0.0-beta.1

package/lib/cjs/types/console/console.d.ts

@@ -1,15 +1,9 @@
-/**
- * Interface representing application message details for console output.
- */
-interface IApplicationMessageToConsole {
-    appName: string;
-    appVersion: string;
-}
+import { IConsoleMessage } from "@expressots/shared";
 /**
  * The Console class provides methods for displaying styled messages in the console.
  * @provide Console
  */
-declare class Console {
+export declare class Console {
     /**
      * Print a message to the console with the specified color style.
      * @param message - The message to be printed.
@@ -22,6 +16,5 @@ declare class Console {
      * @param environment - The server environment.
      * @param consoleMessage - Optional application message details for console output.
      */
-    messageServer(port: number, environment: string, consoleMessage?: IApplicationMessageToConsole): Promise<void>;
+    messageServer(port: number, environment: string, consoleMessage?: IConsoleMessage): Promise<void>;
 }
-export { Console, IApplicationMessageToConsole };

package/lib/cjs/types/console/index.d.ts

@@ -1 +1,2 @@
-export { Console, IApplicationMessageToConsole } from "./console";
+export { IConsoleMessage } from "@expressots/shared";
+export { Console } from "./console";

package/lib/cjs/types/container-module/container-module.d.ts

@@ -1,4 +1,4 @@
-import { ContainerModule, interfaces } from "inversify";
+import { ContainerModule, interfaces } from "../di/inversify";
 /**
  * Key to be used for storing and retrieving binding type metadata.
  */
@@ -7,6 +7,7 @@ export declare const BINDING_TYPE_METADATA_KEY = "binding-type";
  * The scope decorator is a higher order function that can be used to decorate a class with a binding type.
  * @param binding An instance of interfaces.BindingScope which represents the binding type.
  * @returns A decorator function that can be used to decorate a class with a binding type.
+ * @public API
  */
 declare const scope: (binding: interfaces.BindingScope) => (target: any) => void;
 /**
@@ -26,6 +27,7 @@ export declare class BaseModule {
      * @param controllers - An array of controller classes.
      * @param scope - An optional binding scope to be used for all controllers.
      * @returns A ContainerModule with the controller bindings.
+     * @public API
      */
     static createContainerModule(controllers: Array<any>, scope?: interfaces.BindingScope): ContainerModule;
 }

package/lib/cjs/types/decorator/scope-binding.d.ts

@@ -6,15 +6,15 @@
  *
  * @example
  * ```typescript
- * @provide(ServiceIdentifier)
+ * provide(ServiceIdentifier)
  * class MyService {}
  * ```
+ * @public API
  */
-declare const provide: (identifier: any) => (target: any) => any;
+export declare const provide: (identifier: any) => (target: any) => any;
 /**
  * Provides a singleton binding for the given identifier.
  *
- * @remarks
  * Singleton binding ensures that the same instance of a dependency is reused within the entire container.
  *
  * @param identifier - The identifier (e.g., symbol, string, class) for the dependency being registered.
@@ -22,15 +22,15 @@ declare const provide: (identifier: any) => (target: any) => any;
  *
  * @example
  * ```typescript
- * @provideSingleton(ServiceIdentifier)
+ * provideSingleton(ServiceIdentifier)
  * class MyService {}
  * ```
+ * @public API
  */
-declare const provideSingleton: (identifier: any) => (target: any) => any;
+export declare const provideSingleton: (identifier: any) => (target: any) => any;
 /**
  * Provides a transient binding for the given identifier.
  *
- * @remarks
  * Transient binding ensures that a new instance of a dependency is created every time it is resolved.
  *
  * @param identifier - The identifier (e.g., symbol, string, class) for the dependency being registered.
@@ -38,9 +38,9 @@ declare const provideSingleton: (identifier: any) => (target: any) => any;
  *
  * @example
  * ```typescript
- * @provideTransient(ServiceIdentifier)
+ * provideTransient(ServiceIdentifier)
  * class MyService {}
  * ```
+ * @public API
  */
-declare const provideTransient: (identifier: any) => (target: any) => any;
-export { provide, provideSingleton, provideTransient };
+export declare const provideTransient: (identifier: any) => (target: any) => any;

package/lib/cjs/types/di/annotation/decorator_utils.d.ts

@@ -0,0 +1,16 @@
+import { interfaces } from "../interfaces/interfaces";
+type Prototype<T> = {
+    [Property in keyof T]: T[Property] extends NewableFunction ? T[Property] : T[Property] | undefined;
+} & {
+    constructor: NewableFunction;
+};
+interface ConstructorFunction<T = Record<string, unknown>> {
+    new (...args: Array<unknown>): T;
+    prototype: Prototype<T>;
+}
+export type DecoratorTarget<T = unknown> = ConstructorFunction<T> | Prototype<T>;
+declare function tagParameter(annotationTarget: DecoratorTarget, parameterName: string | symbol | undefined, parameterIndex: number, metadata: interfaces.MetadataOrMetadataArray): void;
+declare function tagProperty(annotationTarget: DecoratorTarget, propertyName: string | symbol, metadata: interfaces.MetadataOrMetadataArray): void;
+declare function createTaggedDecorator(metadata: interfaces.MetadataOrMetadataArray): <T>(target: DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;
+declare function decorate(decorator: DecoratorTarget | ParameterDecorator | MethodDecorator, target: object, parameterIndexOrProperty?: number | string): void;
+export { decorate, tagParameter, tagProperty, createTaggedDecorator };

package/lib/cjs/types/di/annotation/inject.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Marks a constructor parameter for injection.
+ * @param serviceIdentifier The service identifier
+ * @return The decorator function
+ * @example
+ * ```typescript
+ * class Engine {}
+ *
+ * class Car {
+ *  constructor(@inject(Engine) engine: Engine) {}
+ * }
+ * ```
+ * @public API
+ */
+declare const inject: <T = unknown>(serviceIdentifier: import("./lazy_service_identifier").ServiceIdentifierOrFunc<T>) => (target: import("./decorator_utils").DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;
+export { inject };

package/lib/cjs/types/di/annotation/inject_base.d.ts

@@ -0,0 +1,3 @@
+import { DecoratorTarget } from "./decorator_utils";
+import { ServiceIdentifierOrFunc } from "./lazy_service_identifier";
+export declare function injectBase(metadataKey: string): <T = unknown>(serviceIdentifier: ServiceIdentifierOrFunc<T>) => (target: DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;

package/lib/cjs/types/di/annotation/injectable.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Marks a class as injectable.
+ * @returns A decorator function
+ * @public API
+ */
+declare function injectable(): <T extends abstract new (...args: Array<unknown>) => unknown>(target: T) => T;
+export { injectable };

package/lib/cjs/types/di/annotation/lazy_service_identifier.d.ts

@@ -0,0 +1,7 @@
+import { interfaces } from "../interfaces/interfaces";
+export type ServiceIdentifierOrFunc<T> = interfaces.ServiceIdentifier<T> | LazyServiceIdentifier<T>;
+export declare class LazyServiceIdentifier<T = unknown> {
+    private _cb;
+    constructor(cb: () => interfaces.ServiceIdentifier<T>);
+    unwrap(): interfaces.ServiceIdentifier<T>;
+}

package/lib/cjs/types/di/annotation/multi_inject.d.ts

@@ -0,0 +1,2 @@
+declare const multiInject: <T = unknown>(serviceIdentifier: import("./lazy_service_identifier").ServiceIdentifierOrFunc<T>) => (target: import("./decorator_utils").DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;
+export { multiInject };

package/lib/cjs/types/di/annotation/named.d.ts

@@ -0,0 +1,2 @@
+declare function named(name: string | number | symbol): <T>(target: import("./decorator_utils").DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;
+export { named };

package/lib/cjs/types/di/annotation/optional.d.ts

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

package/lib/cjs/types/di/annotation/post_construct.d.ts

@@ -0,0 +1,4 @@
+declare const postConstruct: () => (target: {
+    constructor: NewableFunction;
+}, propertyKey: string) => void;
+export { postConstruct };

package/lib/cjs/types/di/annotation/pre_destroy.d.ts

@@ -0,0 +1,4 @@
+declare const preDestroy: () => (target: {
+    constructor: NewableFunction;
+}, propertyKey: string) => void;
+export { preDestroy };

package/lib/cjs/types/di/annotation/property_event_decorator.d.ts

@@ -0,0 +1,4 @@
+declare function propertyEventDecorator(eventKey: string, errorMessage: string): () => (target: {
+    constructor: NewableFunction;
+}, propertyKey: string) => void;
+export { propertyEventDecorator };

package/lib/cjs/types/di/annotation/tagged.d.ts

@@ -0,0 +1,2 @@
+declare function tagged<T>(metadataKey: string | number | symbol, metadataValue: T | unknown): ParameterDecorator;
+export { tagged };

package/lib/cjs/types/di/annotation/target_name.d.ts

@@ -0,0 +1,3 @@
+import { DecoratorTarget } from "./decorator_utils";
+declare function targetName(name: string): (target: DecoratorTarget, targetKey: string, index: number) => void;
+export { targetName };

package/lib/cjs/types/di/annotation/unmanaged.d.ts

@@ -0,0 +1,3 @@
+import { DecoratorTarget } from "./decorator_utils";
+declare function unmanaged(): (target: DecoratorTarget, targetKey: string | undefined, index: number) => void;
+export { unmanaged };

package/lib/cjs/types/di/binding-decorator/constants.d.ts

@@ -0,0 +1,4 @@
+declare const METADATA_KEY: {
+    provide: string;
+};
+export { METADATA_KEY };

package/lib/cjs/types/di/binding-decorator/decorator/fluent_provide.d.ts

@@ -0,0 +1,4 @@
+import interfaces from "../interfaces/interfaces";
+import { interfaces as inversifyInterfaces } from "../../../di/inversify";
+declare function fluentProvide(serviceIdentifier: inversifyInterfaces.ServiceIdentifier<any>): interfaces.ProvideInWhenOnSyntax<any>;
+export default fluentProvide;

package/lib/cjs/types/di/binding-decorator/decorator/provide.d.ts

@@ -0,0 +1,4 @@
+import "reflect-metadata";
+import { interfaces as inversifyInterfaces } from "../../../di/inversify";
+declare function provide(serviceIdentifier: inversifyInterfaces.ServiceIdentifier<any>, force?: boolean): any;
+export default provide;

package/lib/cjs/types/di/binding-decorator/factory/module_factory.d.ts

@@ -0,0 +1,4 @@
+import "reflect-metadata";
+import { interfaces as inversifyInterfaces } from "../../inversify";
+declare function buildProviderModule(): inversifyInterfaces.ContainerModule;
+export default buildProviderModule;

package/lib/cjs/types/di/binding-decorator/index.d.ts

@@ -0,0 +1,8 @@
+import autoProvide from "./utils/auto_wire";
+import provide from "./decorator/provide";
+import fluentProvide from "./decorator/fluent_provide";
+import buildProviderModule from "./factory/module_factory";
+export { fluentProvide };
+export { provide };
+export { autoProvide };
+export { buildProviderModule };

package/lib/cjs/types/di/binding-decorator/interfaces/interfaces.d.ts

@@ -0,0 +1,39 @@
+import { interfaces as inversifyInterfaces } from "../../inversify";
+declare namespace interfaces {
+    type BindConstraint = (bind: inversifyInterfaces.Bind, target: any) => any;
+    interface ProvideSyntax {
+        constraint: BindConstraint;
+        implementationType: any;
+    }
+    interface ProvideDoneSyntax {
+        done(force?: boolean): (target: any) => any;
+    }
+    interface ProvideInSyntax<T> extends ProvideDoneSyntax {
+        inSingletonScope(): ProvideWhenOnSyntax<T>;
+        inTransientScope(): ProvideWhenOnSyntax<T>;
+    }
+    interface ProvideInWhenOnSyntax<T> extends ProvideInSyntax<T>, ProvideWhenSyntax<T>, ProvideOnSyntax<T> {
+    }
+    interface ProvideOnSyntax<T> extends ProvideDoneSyntax {
+        onActivation(fn: (context: inversifyInterfaces.Context, injectable: T) => T): ProvideWhenSyntax<T>;
+    }
+    interface ProvideWhenSyntax<T> extends ProvideDoneSyntax {
+        when(constraint: (request: inversifyInterfaces.Request) => boolean): ProvideOnSyntax<T>;
+        whenTargetNamed(name: string): ProvideOnSyntax<T>;
+        whenTargetTagged(tag: string, value: any): ProvideOnSyntax<T>;
+        whenInjectedInto(parent: Function | string): ProvideOnSyntax<T>;
+        whenParentNamed(name: string): ProvideOnSyntax<T>;
+        whenParentTagged(tag: string, value: any): ProvideOnSyntax<T>;
+        whenAnyAncestorIs(ancestor: Function | string): ProvideOnSyntax<T>;
+        whenNoAncestorIs(ancestor: Function | string): ProvideOnSyntax<T>;
+        whenAnyAncestorNamed(name: string): ProvideOnSyntax<T>;
+        whenAnyAncestorTagged(tag: string, value: any): ProvideOnSyntax<T>;
+        whenNoAncestorNamed(name: string): ProvideOnSyntax<T>;
+        whenNoAncestorTagged(tag: string, value: any): ProvideOnSyntax<T>;
+        whenAnyAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): ProvideOnSyntax<T>;
+        whenNoAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): ProvideOnSyntax<T>;
+    }
+    interface ProvideWhenOnSyntax<T> extends ProvideWhenSyntax<T>, ProvideOnSyntax<T> {
+    }
+}
+export default interfaces;

package/lib/cjs/types/di/binding-decorator/syntax/provide_done_syntax.d.ts

@@ -0,0 +1,7 @@
+import interfaces from "../interfaces/interfaces";
+declare class ProvideDoneSyntax implements interfaces.ProvideDoneSyntax {
+    private _binding;
+    constructor(binding: interfaces.BindConstraint);
+    done(force?: boolean): (target: any) => any;
+}
+export default ProvideDoneSyntax;

package/lib/cjs/types/di/binding-decorator/syntax/provide_in_syntax.d.ts

@@ -0,0 +1,11 @@
+import interfaces from "../interfaces/interfaces";
+import { interfaces as inversifyInterfaces } from "../../inversify";
+declare class ProvideInSyntax<T> implements interfaces.ProvideInSyntax<T> {
+    private _bindingInSyntax;
+    private _provideDoneSyntax;
+    constructor(bindingInSyntax: (bind: inversifyInterfaces.Bind, target: any) => inversifyInterfaces.BindingInSyntax<T>, provideDoneSyntax: interfaces.ProvideDoneSyntax);
+    inSingletonScope(): interfaces.ProvideWhenOnSyntax<T>;
+    inTransientScope(): interfaces.ProvideWhenOnSyntax<T>;
+    done(force?: boolean): any;
+}
+export default ProvideInSyntax;

package/lib/cjs/types/di/binding-decorator/syntax/provide_in_when_on_syntax.d.ts

@@ -0,0 +1,27 @@
+import interfaces from "../interfaces/interfaces";
+import { interfaces as inversifyInterfaces } from "../../inversify";
+declare class ProvideInWhenOnSyntax<T> implements interfaces.ProvideInWhenOnSyntax<T> {
+    private _provideInSyntax;
+    private _provideWhenSyntax;
+    private _provideOnSyntax;
+    constructor(provideInSyntax: interfaces.ProvideInSyntax<T>, provideWhenSyntax: interfaces.ProvideWhenSyntax<T>, provideOnSyntax: interfaces.ProvideOnSyntax<T>);
+    when(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    whenTargetNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenTargetTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenInjectedInto(parent: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenParentNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenParentTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorIs(ancestor: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    onActivation(fn: (context: inversifyInterfaces.Context, injectable: T) => T): interfaces.ProvideWhenSyntax<T>;
+    inSingletonScope(): interfaces.ProvideWhenOnSyntax<T>;
+    inTransientScope(): interfaces.ProvideWhenOnSyntax<T>;
+    done(force?: boolean): any;
+}
+export default ProvideInWhenOnSyntax;

package/lib/cjs/types/di/binding-decorator/syntax/provide_on_syntax.d.ts

@@ -0,0 +1,10 @@
+import interfaces from "../interfaces/interfaces";
+import { interfaces as inversifyInterfaces } from "../../inversify";
+declare class ProvideOnSyntax<T> implements interfaces.ProvideOnSyntax<T> {
+    private _bindingOnSyntax;
+    private _provideDoneSyntax;
+    constructor(bindingOnSyntax: (bind: inversifyInterfaces.Bind, target: any) => inversifyInterfaces.BindingOnSyntax<T>, provideDoneSyntax: interfaces.ProvideDoneSyntax);
+    onActivation(fn: (context: inversifyInterfaces.Context, injectable: T) => T): interfaces.ProvideWhenSyntax<T>;
+    done(force?: boolean): any;
+}
+export default ProvideOnSyntax;

package/lib/cjs/types/di/binding-decorator/syntax/provide_when_on_syntax.d.ts

@@ -0,0 +1,24 @@
+import interfaces from "../interfaces/interfaces";
+import { interfaces as inversifyInterfaces } from "../../inversify";
+declare class ProvideWhenOnSyntax<T> implements interfaces.ProvideWhenOnSyntax<T> {
+    private _provideWhenSyntax;
+    private _provideOnSyntax;
+    constructor(provideWhenSyntax: interfaces.ProvideWhenSyntax<T>, provideOnSyntax: interfaces.ProvideOnSyntax<T>);
+    when(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    whenTargetNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenTargetTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenInjectedInto(parent: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenParentNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenParentTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorIs(ancestor: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    onActivation(fn: (context: inversifyInterfaces.Context, injectable: T) => T): interfaces.ProvideWhenSyntax<T>;
+    done(force?: boolean): any;
+}
+export default ProvideWhenOnSyntax;

package/lib/cjs/types/di/binding-decorator/syntax/provide_when_syntax.d.ts

@@ -0,0 +1,23 @@
+import interfaces from "../interfaces/interfaces";
+import { interfaces as inversifyInterfaces } from "../../inversify";
+declare class ProvideWhenSyntax<T> implements interfaces.ProvideWhenSyntax<T> {
+    private _bindingWhenSyntax;
+    private _provideDoneSyntax;
+    constructor(bindingWhenSyntax: (bind: inversifyInterfaces.Bind, target: any) => inversifyInterfaces.BindingWhenSyntax<T>, provideDoneSyntax: interfaces.ProvideDoneSyntax);
+    when(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    whenTargetNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenTargetTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenInjectedInto(parent: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenParentNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenParentTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorIs(ancestor: Function | string): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorNamed(name: string): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorTagged(tag: string, value: any): interfaces.ProvideOnSyntax<T>;
+    whenAnyAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    whenNoAncestorMatches(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
+    done(force?: boolean): (target: any) => any;
+}
+export default ProvideWhenSyntax;

package/lib/cjs/types/di/binding-decorator/utils/auto_wire.d.ts

@@ -0,0 +1,3 @@
+import { interfaces } from "../../inversify";
+declare function autoProvide(container: interfaces.Container, ...modules: Array<any>): void;
+export default autoProvide;

package/lib/cjs/types/di/bindings/binding.d.ts

@@ -0,0 +1,20 @@
+import { interfaces } from "../interfaces/interfaces";
+declare class Binding<TActivated> implements interfaces.Binding<TActivated> {
+    id: number;
+    moduleId: interfaces.ContainerModuleBase["id"];
+    activated: boolean;
+    serviceIdentifier: interfaces.ServiceIdentifier<TActivated>;
+    implementationType: interfaces.Newable<TActivated> | TActivated | null;
+    cache: TActivated | Promise<TActivated> | null;
+    dynamicValue: interfaces.DynamicValue<TActivated> | null;
+    scope: interfaces.BindingScope;
+    type: interfaces.BindingType;
+    factory: interfaces.FactoryCreator<unknown> | null;
+    provider: interfaces.ProviderCreator<unknown> | null;
+    constraint: interfaces.ConstraintFunction;
+    onActivation: interfaces.BindingActivation<TActivated> | null;
+    onDeactivation: interfaces.BindingDeactivation<TActivated> | null;
+    constructor(serviceIdentifier: interfaces.ServiceIdentifier<TActivated>, scope: interfaces.BindingScope);
+    clone(): interfaces.Binding<TActivated>;
+}
+export { Binding };

package/lib/cjs/types/di/bindings/binding_count.d.ts

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

package/lib/cjs/types/di/constants/error_msgs.d.ts

@@ -0,0 +1,32 @@
+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 LAZY_IN_SYNC: (key: unknown) => string;
+export declare const INVALID_TO_SELF_VALUE: string;
+export declare const INVALID_DECORATOR_OPERATION: string;
+export declare const ARGUMENTS_LENGTH_MISMATCH: (...values: Array<unknown>) => 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_PRE_DESTROY_METHODS = "Cannot apply @preDestroy decorator multiple times in the same class";
+export declare const MULTIPLE_POST_CONSTRUCT_METHODS = "Cannot apply @postConstruct decorator multiple times in the same class";
+export declare const ASYNC_UNBIND_REQUIRED = "Attempting to unbind dependency with asynchronous destruction (@preDestroy or onDeactivation)";
+export declare const POST_CONSTRUCT_ERROR: (clazz: string, errorMessage: string) => string;
+export declare const PRE_DESTROY_ERROR: (clazz: string, errorMessage: string) => string;
+export declare const ON_DEACTIVATION_ERROR: (clazz: string, errorMessage: string) => string;
+export declare const CIRCULAR_DEPENDENCY_IN_FACTORY: (factoryType: string, serviceIdentifier: string) => string;
+export declare const STACK_OVERFLOW = "Maximum call stack size exceeded";

package/lib/cjs/types/di/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 };

package/lib/cjs/types/di/constants/metadata_keys.d.ts

@@ -0,0 +1,13 @@
+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";
+export declare const PRE_DESTROY = "pre_destroy";
+export declare const NON_CUSTOM_TAG_KEYS: Array<string>;

package/lib/cjs/types/di/container/container.d.ts

@@ -0,0 +1,73 @@
+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 _activations;
+    private _deactivations;
+    private _snapshots;
+    private _metadataReader;
+    private _moduleActivationStore;
+    static merge(container1: interfaces.Container, container2: interfaces.Container, ...containers: Array<interfaces.Container>): interfaces.Container;
+    constructor(containerOptions?: interfaces.ContainerOptions);
+    load(...modules: Array<interfaces.ContainerModule>): void;
+    loadAsync(...modules: Array<interfaces.AsyncContainerModule>): Promise<void>;
+    unload(...modules: Array<interfaces.ContainerModuleBase>): void;
+    unloadAsync(...modules: Array<interfaces.ContainerModuleBase>): Promise<void>;
+    bind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;
+    rebind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;
+    rebindAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Promise<interfaces.BindingToSyntax<T>>;
+    unbind(serviceIdentifier: interfaces.ServiceIdentifier): void;
+    unbindAsync(serviceIdentifier: interfaces.ServiceIdentifier): Promise<void>;
+    unbindAll(): void;
+    unbindAllAsync(): Promise<void>;
+    onActivation<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, onActivation: interfaces.BindingActivation<T>): void;
+    onDeactivation<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, onDeactivation: interfaces.BindingDeactivation<T>): void;
+    isBound(serviceIdentifier: interfaces.ServiceIdentifier<unknown>): boolean;
+    isCurrentBound<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): boolean;
+    isBoundNamed(serviceIdentifier: interfaces.ServiceIdentifier, named: string | number | symbol): boolean;
+    isBoundTagged(serviceIdentifier: interfaces.ServiceIdentifier, key: string | number | symbol, value: unknown): boolean;
+    snapshot(): void;
+    restore(): void;
+    createChild(containerOptions?: interfaces.ContainerOptions): Container;
+    applyMiddleware(...middlewares: Array<interfaces.Middleware>): void;
+    applyCustomMetadataReader(metadataReader: interfaces.MetadataReader): void;
+    get<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T;
+    getAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Promise<T>;
+    getTagged<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: unknown): T;
+    getTaggedAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Promise<T>;
+    getNamed<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): T;
+    getNamedAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): Promise<T>;
+    getAll<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Array<T>;
+    getAllAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Promise<Array<T>>;
+    getAllTagged<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Array<T>;
+    getAllTaggedAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Promise<Array<T>>;
+    getAllNamed<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): Array<T>;
+    getAllNamedAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): Promise<Array<T>>;
+    resolve<T>(constructorFunction: interfaces.Newable<T>): T;
+    private _preDestroy;
+    private _removeModuleHandlers;
+    private _removeModuleBindings;
+    private _deactivate;
+    private _handleDeactivationError;
+    private _deactivateContainer;
+    private _deactivateContainerAsync;
+    private _getContainerModuleHelpersFactory;
+    private _getAll;
+    private _get;
+    private _getButThrowIfAsync;
+    private _getAllArgs;
+    private _getNotAllArgs;
+    private _planAndResolve;
+    private _deactivateIfSingleton;
+    private _deactivateSingletons;
+    private _deactivateSingletonsAsync;
+    private _propagateContainerDeactivationThenBindingAndPreDestroy;
+    private _propagateContainerDeactivationThenBindingAndPreDestroyAsync;
+    private _removeServiceFromDictionary;
+    private _bindingDeactivationAndPreDestroy;
+    private _bindingDeactivationAndPreDestroyAsync;
+}
+export { Container };

package/lib/cjs/types/di/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);
+}

package/lib/cjs/types/di/container/container_snapshot.d.ts

@@ -0,0 +1,10 @@
+import { interfaces } from "../interfaces/interfaces";
+declare class ContainerSnapshot implements interfaces.ContainerSnapshot {
+    bindings: interfaces.Lookup<interfaces.Binding<unknown>>;
+    activations: interfaces.Lookup<interfaces.BindingActivation<unknown>>;
+    deactivations: interfaces.Lookup<interfaces.BindingDeactivation<unknown>>;
+    middleware: interfaces.Next | null;
+    moduleActivationStore: interfaces.ModuleActivationStore;
+    static of(bindings: interfaces.Lookup<interfaces.Binding<unknown>>, middleware: interfaces.Next | null, activations: interfaces.Lookup<interfaces.BindingActivation<unknown>>, deactivations: interfaces.Lookup<interfaces.BindingDeactivation<unknown>>, moduleActivationStore: interfaces.ModuleActivationStore): ContainerSnapshot;
+}
+export { ContainerSnapshot };

package/lib/cjs/types/di/container/lookup.d.ts

@@ -0,0 +1,16 @@
+import { interfaces } from "../interfaces/interfaces";
+declare class Lookup<T> implements interfaces.Lookup<T> {
+    private _map;
+    constructor();
+    getMap(): Map<interfaces.ServiceIdentifier, Array<T>>;
+    add(serviceIdentifier: interfaces.ServiceIdentifier, value: T): void;
+    get(serviceIdentifier: interfaces.ServiceIdentifier): Array<T>;
+    remove(serviceIdentifier: interfaces.ServiceIdentifier): void;
+    removeIntersection(lookup: interfaces.Lookup<T>): void;
+    removeByCondition(condition: (item: T) => boolean): Array<T>;
+    hasKey(serviceIdentifier: interfaces.ServiceIdentifier): boolean;
+    clone(): interfaces.Lookup<T>;
+    traverse(func: (key: interfaces.ServiceIdentifier, value: Array<T>) => void): void;
+    private _setValue;
+}
+export { Lookup };

package/lib/cjs/types/di/container/module_activation_store.d.ts

@@ -0,0 +1,10 @@
+import { interfaces } from "../interfaces/interfaces";
+export declare class ModuleActivationStore implements interfaces.ModuleActivationStore {
+    private _map;
+    remove(moduleId: number): interfaces.ModuleActivationHandlers;
+    addDeactivation(moduleId: number, serviceIdentifier: interfaces.ServiceIdentifier<unknown>, onDeactivation: interfaces.BindingDeactivation<unknown>): void;
+    addActivation(moduleId: number, serviceIdentifier: interfaces.ServiceIdentifier<unknown>, onActivation: interfaces.BindingActivation<unknown>): void;
+    clone(): interfaces.ModuleActivationStore;
+    private _getModuleActivationHandlers;
+    private _getEmptyHandlersStore;
+}