@expressots/core 3.0.0 → 4.0.0-preview.3

package/lib/esm/types/di/interfaces/interfaces.d.ts

@@ -0,0 +1,300 @@
+import { FactoryType } from "../utils/factory_type.js";
+declare namespace interfaces {
+    export type DynamicValue<T> = (context: interfaces.Context) => T | Promise<T>;
+    export type ContainerResolution<T> = T | Promise<T> | Array<T | Promise<T>>;
+    type AsyncCallback<TCallback> = TCallback extends (...args: infer TArgs) => infer TResult ? (...args: TArgs) => Promise<TResult> : never;
+    export type BindingScope = "Singleton" | "Transient" | "Request" | string;
+    export type BindingType = "ConstantValue" | "Constructor" | "DynamicValue" | "Factory" | "Function" | "Instance" | "Invalid" | "Provider";
+    export type TargetType = "ConstructorArgument" | "ClassProperty" | "Variable";
+    export interface Scope {
+        Request: interfaces.BindingScope;
+        Singleton: interfaces.BindingScope;
+        Transient: interfaces.BindingScope;
+    }
+    export interface BindingTypeEnum {
+        ConstantValue: interfaces.BindingType;
+        Constructor: interfaces.BindingType;
+        DynamicValue: interfaces.BindingType;
+        Factory: interfaces.BindingType;
+        Function: interfaces.BindingType;
+        Instance: interfaces.BindingType;
+        Invalid: interfaces.BindingType;
+        Provider: interfaces.BindingType;
+    }
+    export interface TargetTypeEnum {
+        ConstructorArgument: interfaces.TargetType;
+        ClassProperty: interfaces.TargetType;
+        Variable: interfaces.TargetType;
+    }
+    export type Newable<T> = new (...args: Array<unknown>) => T;
+    export type Instance<T> = T & Record<string, () => void>;
+    export interface Abstract<T> {
+        prototype: T;
+    }
+    export type ServiceIdentifier<T = unknown> = string | symbol | Newable<T> | Abstract<T>;
+    export interface Clonable<T> {
+        clone(): T;
+    }
+    export type BindingActivation<T = unknown> = (context: interfaces.Context, injectable: T) => T | Promise<T>;
+    export type BindingDeactivation<T = unknown> = (injectable: T) => void | Promise<void>;
+    export interface Binding<TActivated = unknown> extends Clonable<Binding<TActivated>> {
+        id: number;
+        moduleId: ContainerModuleBase["id"];
+        activated: boolean;
+        serviceIdentifier: ServiceIdentifier<TActivated>;
+        constraint: ConstraintFunction;
+        dynamicValue: DynamicValue<TActivated> | null;
+        scope: BindingScope;
+        type: BindingType;
+        implementationType: Newable<TActivated> | TActivated | null;
+        factory: FactoryCreator<unknown> | null;
+        provider: ProviderCreator<unknown> | null;
+        onActivation: BindingActivation<TActivated> | null;
+        onDeactivation: BindingDeactivation<TActivated> | null;
+        cache: null | TActivated | Promise<TActivated>;
+    }
+    export type SimpleFactory<T, U extends Array<unknown> = Array<unknown>> = (...args: U) => T;
+    export type MultiFactory<T, U extends Array<unknown> = Array<unknown>, V extends Array<unknown> = Array<unknown>> = (...args: U) => SimpleFactory<T, V>;
+    export type Factory<T, U extends Array<unknown> = Array<unknown>, V extends Array<unknown> = Array<unknown>> = SimpleFactory<T, U> | MultiFactory<T, U, V>;
+    export type FactoryCreator<T, U extends Array<unknown> = Array<unknown>, V extends Array<unknown> = Array<unknown>> = (context: Context) => Factory<T, U, V>;
+    export type AutoNamedFactory<T> = SimpleFactory<T, [string]>;
+    export type AutoFactory<T> = SimpleFactory<T, []>;
+    export type FactoryTypeFunction<T = unknown> = (context: interfaces.Context) => T | Promise<T>;
+    export interface FactoryDetails {
+        factoryType: FactoryType;
+        factory: FactoryTypeFunction | null;
+    }
+    export type Provider<T> = (...args: Array<unknown>) => ((...args: Array<unknown>) => Promise<T>) | Promise<T>;
+    export type ProviderCreator<T> = (context: Context) => Provider<T>;
+    export interface NextArgs<T = unknown> {
+        avoidConstraints: boolean;
+        contextInterceptor: (contexts: Context) => Context;
+        isMultiInject: boolean;
+        targetType: TargetType;
+        serviceIdentifier: interfaces.ServiceIdentifier<T>;
+        key?: string | number | symbol | undefined;
+        value?: unknown;
+    }
+    export type Next = (args: NextArgs) => unknown | Array<unknown>;
+    export type Middleware = (next: Next) => Next;
+    export type ContextInterceptor = (context: interfaces.Context) => interfaces.Context;
+    export interface Context {
+        id: number;
+        container: Container;
+        plan: Plan;
+        currentRequest: Request;
+        addPlan(plan: Plan): void;
+        setCurrentRequest(request: Request): void;
+    }
+    export type MetadataOrMetadataArray = Metadata | Array<Metadata>;
+    export interface Metadata<TValue = unknown> {
+        key: string | number | symbol;
+        value: TValue;
+    }
+    export interface Plan {
+        parentContext: Context;
+        rootRequest: Request;
+    }
+    export interface QueryableString {
+        startsWith(searchString: string): boolean;
+        endsWith(searchString: string): boolean;
+        contains(searchString: string): boolean;
+        equals(compareString: string): boolean;
+        value(): string;
+    }
+    export type ResolveRequestHandler = (request: interfaces.Request) => unknown;
+    export type RequestScope = Map<unknown, unknown>;
+    export interface Request {
+        id: number;
+        serviceIdentifier: ServiceIdentifier;
+        parentContext: Context;
+        parentRequest: Request | null;
+        childRequests: Array<Request>;
+        target: Target;
+        bindings: Array<Binding<unknown>>;
+        requestScope: RequestScope | null;
+        addChildRequest(serviceIdentifier: ServiceIdentifier, bindings: Binding<unknown> | Array<Binding<unknown>>, target: Target): Request;
+    }
+    export interface Target {
+        id: number;
+        serviceIdentifier: ServiceIdentifier;
+        type: TargetType;
+        name: QueryableString;
+        identifier: string | symbol;
+        metadata: Array<Metadata>;
+        getNamedTag(): interfaces.Metadata<string> | null;
+        getCustomTags(): Array<interfaces.Metadata> | null;
+        hasTag(key: string | number | symbol): boolean;
+        isArray(): boolean;
+        matchesArray(name: interfaces.ServiceIdentifier): boolean;
+        isNamed(): boolean;
+        isTagged(): boolean;
+        isOptional(): boolean;
+        matchesNamedTag(name: string): boolean;
+        matchesTag(key: string | number | symbol): (value: unknown) => boolean;
+    }
+    /**
+     * Interface for container options that can be passed to the AppContainer class.
+     * @public API
+     */
+    export interface ContainerOptions {
+        /**
+         * Allows auto-binding of injectable classes.
+         */
+        autoBindInjectable?: boolean;
+        /**
+         * The default scope for bindings in the container.
+         * It can be set to Request (default), Singleton, or Transient.
+         */
+        defaultScope?: BindingScope | undefined;
+        /**
+         * Allows skipping of base class checks when working with derived classes.
+         */
+        skipBaseClassChecks?: boolean;
+    }
+    export interface Container {
+        id: number;
+        parent: Container | null;
+        options: ContainerOptions;
+        bind<T>(serviceIdentifier: ServiceIdentifier<T>): BindingToSyntax<T>;
+        rebind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;
+        rebindAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Promise<interfaces.BindingToSyntax<T>>;
+        unbind(serviceIdentifier: ServiceIdentifier): void;
+        unbindAsync(serviceIdentifier: interfaces.ServiceIdentifier): Promise<void>;
+        unbindAll(): void;
+        unbindAllAsync(): Promise<void>;
+        isBound(serviceIdentifier: ServiceIdentifier): boolean;
+        isCurrentBound<T>(serviceIdentifier: ServiceIdentifier<T>): boolean;
+        isBoundNamed(serviceIdentifier: ServiceIdentifier, named: string | number | symbol): boolean;
+        isBoundTagged(serviceIdentifier: ServiceIdentifier, key: string | number | symbol, value: unknown): boolean;
+        get<T>(serviceIdentifier: ServiceIdentifier<T>): T;
+        getNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): T;
+        getTagged<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): T;
+        getAll<T>(serviceIdentifier: ServiceIdentifier<T>): Array<T>;
+        getAllTagged<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Array<T>;
+        getAllNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): Array<T>;
+        getAsync<T>(serviceIdentifier: ServiceIdentifier<T>): Promise<T>;
+        getNamedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): Promise<T>;
+        getTaggedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Promise<T>;
+        getAllAsync<T>(serviceIdentifier: ServiceIdentifier<T>): Promise<Array<T>>;
+        getAllTaggedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Promise<Array<T>>;
+        getAllNamedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): Promise<Array<T>>;
+        onActivation<T>(serviceIdentifier: ServiceIdentifier<T>, onActivation: BindingActivation<T>): void;
+        onDeactivation<T>(serviceIdentifier: ServiceIdentifier<T>, onDeactivation: BindingDeactivation<T>): void;
+        resolve<T>(constructorFunction: interfaces.Newable<T>): T;
+        load(...modules: Array<ContainerModule>): void;
+        loadAsync(...modules: Array<AsyncContainerModule>): Promise<void>;
+        unload(...modules: Array<ContainerModuleBase>): void;
+        unloadAsync(...modules: Array<ContainerModuleBase>): Promise<void>;
+        applyCustomMetadataReader(metadataReader: MetadataReader): void;
+        applyMiddleware(...middleware: Array<Middleware>): void;
+        snapshot(): void;
+        restore(): void;
+        createChild(): Container;
+    }
+    export type Bind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;
+    export type Rebind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;
+    export type Unbind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => void;
+    export type UnbindAsync = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => Promise<void>;
+    export type IsBound = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => boolean;
+    export interface ContainerModuleBase {
+        id: number;
+    }
+    export interface ContainerModule extends ContainerModuleBase {
+        registry: ContainerModuleCallBack;
+    }
+    export interface AsyncContainerModule extends ContainerModuleBase {
+        registry: AsyncContainerModuleCallBack;
+    }
+    export interface ModuleActivationHandlers {
+        onActivations: Lookup<BindingActivation<unknown>>;
+        onDeactivations: Lookup<BindingDeactivation<unknown>>;
+    }
+    export interface ModuleActivationStore extends Clonable<ModuleActivationStore> {
+        addDeactivation(moduleId: ContainerModuleBase["id"], serviceIdentifier: ServiceIdentifier<unknown>, onDeactivation: interfaces.BindingDeactivation<unknown>): void;
+        addActivation(moduleId: ContainerModuleBase["id"], serviceIdentifier: ServiceIdentifier<unknown>, onActivation: interfaces.BindingActivation<unknown>): void;
+        remove(moduleId: ContainerModuleBase["id"]): ModuleActivationHandlers;
+    }
+    export type ContainerModuleCallBack = (bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind, unbindAsync: interfaces.UnbindAsync, onActivation: interfaces.Container["onActivation"], onDeactivation: interfaces.Container["onDeactivation"]) => void;
+    export type AsyncContainerModuleCallBack = AsyncCallback<ContainerModuleCallBack>;
+    export interface ContainerSnapshot {
+        bindings: Lookup<Binding<unknown>>;
+        activations: Lookup<BindingActivation<unknown>>;
+        deactivations: Lookup<BindingDeactivation<unknown>>;
+        middleware: Next | null;
+        moduleActivationStore: interfaces.ModuleActivationStore;
+    }
+    export interface Lookup<T> extends Clonable<Lookup<T>> {
+        [x: string]: any;
+        add(serviceIdentifier: ServiceIdentifier, value: T): void;
+        getMap(): Map<interfaces.ServiceIdentifier, Array<T>>;
+        get(serviceIdentifier: ServiceIdentifier): Array<T>;
+        remove(serviceIdentifier: interfaces.ServiceIdentifier): void;
+        removeByCondition(condition: (item: T) => boolean): Array<T>;
+        removeIntersection(lookup: interfaces.Lookup<T>): void;
+        hasKey(serviceIdentifier: ServiceIdentifier): boolean;
+        clone(): Lookup<T>;
+        traverse(func: (key: interfaces.ServiceIdentifier, value: Array<T>) => void): void;
+    }
+    export interface BindingOnSyntax<T> {
+        onActivation(fn: (context: Context, injectable: T) => T | Promise<T>): BindingWhenSyntax<T>;
+        onDeactivation(fn: (injectable: T) => void | Promise<void>): BindingWhenSyntax<T>;
+    }
+    export interface BindingWhenSyntax<T> {
+        when(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
+        whenTargetNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenTargetIsDefault(): BindingOnSyntax<T>;
+        whenTargetTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
+        whenInjectedInto(parent: NewableFunction | string): BindingOnSyntax<T>;
+        whenParentNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenParentTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
+        whenAnyAncestorIs(ancestor: NewableFunction | string): BindingOnSyntax<T>;
+        whenNoAncestorIs(ancestor: NewableFunction | string): BindingOnSyntax<T>;
+        whenAnyAncestorNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenAnyAncestorTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
+        whenNoAncestorNamed(name: string | number | symbol): BindingOnSyntax<T>;
+        whenNoAncestorTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
+        whenAnyAncestorMatches(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
+        whenNoAncestorMatches(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
+    }
+    export interface BindingWhenOnSyntax<T> extends BindingWhenSyntax<T>, BindingOnSyntax<T> {
+    }
+    export interface BindingInSyntax<T> {
+        inSingletonScope(): BindingWhenOnSyntax<T>;
+        inTransientScope(): BindingWhenOnSyntax<T>;
+        inRequestScope(): BindingWhenOnSyntax<T>;
+        inScope(scope: string): BindingWhenOnSyntax<T>;
+    }
+    export interface BindingInWhenOnSyntax<T> extends BindingInSyntax<T>, BindingWhenOnSyntax<T> {
+    }
+    export interface BindingToSyntax<T> {
+        to(constructor: Newable<T>): BindingInWhenOnSyntax<T>;
+        toSelf(): BindingInWhenOnSyntax<T>;
+        toConstantValue(value: T): BindingWhenOnSyntax<T>;
+        toDynamicValue(func: DynamicValue<T>): BindingInWhenOnSyntax<T>;
+        toConstructor<T2>(constructor: Newable<T2>): BindingWhenOnSyntax<T>;
+        toFactory<T2, T3 extends Array<unknown> = Array<unknown>, T4 extends Array<unknown> = Array<unknown>>(factory: FactoryCreator<T2, T3, T4>): BindingWhenOnSyntax<T>;
+        toFunction(func: T): BindingWhenOnSyntax<T>;
+        toAutoFactory<T2>(serviceIdentifier: ServiceIdentifier<T2>): BindingWhenOnSyntax<T>;
+        toAutoNamedFactory<T2>(serviceIdentifier: ServiceIdentifier<T2>): BindingWhenOnSyntax<T>;
+        toProvider<T2>(provider: ProviderCreator<T2>): BindingWhenOnSyntax<T>;
+        toService(service: ServiceIdentifier<T>): void;
+    }
+    export interface ConstraintFunction {
+        metaData?: Metadata;
+        (request: Request | null): boolean;
+    }
+    export interface MetadataReader {
+        getConstructorMetadata(constructorFunc: NewableFunction): ConstructorMetadata;
+        getPropertiesMetadata(constructorFunc: NewableFunction): MetadataMap;
+    }
+    export interface MetadataMap {
+        [propertyNameOrArgumentIndex: string | symbol]: Array<Metadata>;
+    }
+    export interface ConstructorMetadata {
+        compilerGeneratedMetadata: Array<NewableFunction> | undefined;
+        userGeneratedMetadata: MetadataMap;
+    }
+    export {};
+}
+export { interfaces };

package/lib/esm/types/di/inversify.d.ts

@@ -0,0 +1,54 @@
+/**
+ * InversifyJS Dependency Injection Library
+ *
+ * @layer public
+ * @audience application-developers
+ * @concept dependency-injection
+ * @difficulty intermediate
+ *
+ * @summary Quick Start
+ * ExpressoTS uses InversifyJS for dependency injection. Most InversifyJS APIs are available here.
+ *
+ * @example
+ * ```typescript
+ * import { Container, injectable, inject } from "@expressots/core";
+ *
+ * @injectable()
+ * export class MyService {
+ *   constructor(@inject("IDependency") private dep: IDependency) {}
+ * }
+ * ```
+ *
+ * @note
+ * This module re-exports InversifyJS APIs. For full InversifyJS documentation,
+ * see: https://github.com/inversify/InversifyJS
+ *
+ * @public API
+ */
+import * as keys from "./constants/metadata_keys.js";
+export declare const METADATA_KEY: typeof keys;
+export { Container } from "./container/container.js";
+export { Scope, BindingTypeEnum, TargetTypeEnum, } from "./constants/literal_types.js";
+export { AsyncContainerModule, ContainerModule, } from "./container/container_module.js";
+export { createTaggedDecorator } from "./annotation/decorator_utils.js";
+export { injectable } from "./annotation/injectable.js";
+export { tagged } from "./annotation/tagged.js";
+export { named } from "./annotation/named.js";
+export { inject } from "./annotation/inject.js";
+export { LazyServiceIdentifier } from "./annotation/lazy_service_identifier.js";
+export { LazyServiceIdentifier as LazyServiceIdentifer } from "./annotation/lazy_service_identifier.js";
+export { optional } from "./annotation/optional.js";
+export { unmanaged } from "./annotation/unmanaged.js";
+export { multiInject } from "./annotation/multi_inject.js";
+export { targetName } from "./annotation/target_name.js";
+export { postConstruct } from "./annotation/post_construct.js";
+export { preDestroy } from "./annotation/pre_destroy.js";
+export { MetadataReader } from "./planning/metadata_reader.js";
+export { id } from "./utils/id.js";
+export { interfaces } from "./interfaces/interfaces.js";
+export { decorate } from "./annotation/decorator_utils.js";
+export { forEachBinding, getBoundImplementations, } from "./container-introspection.js";
+export { traverseAncerstors, taggedConstraint, namedConstraint, typeConstraint, } from "./syntax/constraint_helpers.js";
+export { getServiceIdentifierAsString } from "./utils/serialization.js";
+export { multiBindToService } from "./utils/binding_utils.js";
+export { ScopeRegistry, globalScopeRegistry } from "./scope/scope-registry.js";

package/lib/esm/types/di/planning/context.d.ts

@@ -0,0 +1,11 @@
+import { interfaces } from "../interfaces/interfaces.js";
+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 };

package/lib/esm/types/di/planning/metadata.d.ts

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

package/lib/esm/types/di/planning/metadata_reader.d.ts

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

package/lib/esm/types/di/planning/plan.d.ts

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

package/lib/esm/types/di/planning/planner.d.ts

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

package/lib/esm/types/di/planning/queryable_string.d.ts

@@ -0,0 +1,11 @@
+import { interfaces } from "../interfaces/interfaces.js";
+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 };

package/lib/esm/types/di/planning/reflection_utils.d.ts

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

package/lib/esm/types/di/planning/request.d.ts

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

package/lib/esm/types/di/planning/target.d.ts

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

package/lib/esm/types/di/resolution/instantiation.d.ts

@@ -0,0 +1,3 @@
+import { interfaces } from "../interfaces/interfaces.js";
+declare function resolveInstance<T>(binding: interfaces.Binding<T>, constr: interfaces.Newable<T>, childRequests: Array<interfaces.Request>, resolveRequest: interfaces.ResolveRequestHandler): T | Promise<T>;
+export { resolveInstance };

package/lib/esm/types/di/resolution/resolver.d.ts

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

package/lib/esm/types/di/scope/scope-registry.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Registry for managing custom scope stores in dependency injection.
+ *
+ * @layer public
+ * @audience application-developers
+ * @concept scope-management
+ * @difficulty advanced
+ *
+ * @summary Quick Start
+ * Manages custom scope stores for multi-tenant or transaction-scoped services.
+ * Typically used internally by the framework.
+ *
+ * @example
+ * ```typescript
+ * const registry = new ScopeRegistry();
+ * const tenantScope = registry.getScopeStore("tenant");
+ * tenantScope.set(bindingId, instance);
+ * ```
+ *
+ * @layer internal
+ * @audience framework-developers
+ *
+ * **Internal Architecture**
+ *
+ * ScopeRegistry maintains separate stores for each custom scope:
+ * - Each scope has its own Map of binding IDs to instances
+ * - Instances are cached per scope value
+ * - Used by InversifyJS container for custom scope resolution
+ *
+ * **Use Cases**
+ * - Multi-tenant applications (tenant scope)
+ * - Transaction management (transaction scope)
+ * - Workflow orchestration (workflow scope)
+ *
+ * @see {@link provideInScope} for registering services with custom scopes
+ *
+ * @public API
+ */
+export declare class ScopeRegistry {
+    private stores;
+    /**
+     * Get or create a scope store for the given scope name.
+     *
+     * @layer public
+     * @audience application-developers
+     *
+     * @param scopeName - The name of the custom scope (e.g., "tenant", "transaction")
+     * @returns The scope store Map for the given scope name
+     *
+     * @example
+     * ```typescript
+     * const registry = new ScopeRegistry();
+     * const tenantScope = registry.getScopeStore("tenant");
+     * // Use tenantScope to store/retrieve instances
+     * ```
+     *
+     * @public API
+     */
+    getScopeStore(scopeName: string): Map<number, unknown>;
+    /**
+     * Check if a scope store exists for the given scope name.
+     * @param scopeName - The name of the custom scope
+     * @returns True if the scope store exists, false otherwise
+     */
+    hasScope(scopeName: string): boolean;
+    /**
+     * Clear all instances from a specific scope store.
+     * @param scopeName - The name of the custom scope to clear
+     */
+    clearScope(scopeName: string): void;
+    /**
+     * Remove a scope store entirely.
+     * @param scopeName - The name of the custom scope to remove
+     */
+    removeScope(scopeName: string): void;
+    /**
+     * Clear all scope stores.
+     */
+    clearAll(): void;
+    /**
+     * Get all registered scope names.
+     * @returns Array of scope names
+     */
+    getScopeNames(): Array<string>;
+}
+/**
+ * Global scope registry instance.
+ * This is used by the container to manage custom scopes.
+ * @internal
+ */
+export declare const globalScopeRegistry: ScopeRegistry;

package/lib/esm/types/di/scope/scope.d.ts

@@ -0,0 +1,3 @@
+import type { interfaces } from "../interfaces/interfaces.js";
+export declare const tryGetFromScope: <T>(requestScope: interfaces.RequestScope, binding: interfaces.Binding<T>) => T | Promise<T> | null;
+export declare const saveToScope: <T>(requestScope: interfaces.RequestScope, binding: interfaces.Binding<T>, result: T | Promise<T>) => void;

package/lib/esm/types/di/syntax/binding_in_syntax.d.ts

@@ -0,0 +1,10 @@
+import { interfaces } from "../interfaces/interfaces.js";
+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>;
+    inScope(scope: string): interfaces.BindingWhenOnSyntax<T>;
+}
+export { BindingInSyntax };

package/lib/esm/types/di/syntax/binding_in_when_on_syntax.d.ts

@@ -0,0 +1,30 @@
+import { interfaces } from "../interfaces/interfaces.js";
+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>;
+    inScope(scope: string): 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: unknown): interfaces.BindingOnSyntax<T>;
+    whenInjectedInto(parent: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenParentNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenParentTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorTagged(tag: string, value: unknown): 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 | Promise<T>): interfaces.BindingWhenSyntax<T>;
+    onDeactivation(handler: (injectable: T) => void | Promise<void>): interfaces.BindingWhenSyntax<T>;
+}
+export { BindingInWhenOnSyntax };

package/lib/esm/types/di/syntax/binding_on_syntax.d.ts

@@ -0,0 +1,8 @@
+import { interfaces } from "../interfaces/interfaces.js";
+declare class BindingOnSyntax<T> implements interfaces.BindingOnSyntax<T> {
+    private _binding;
+    constructor(binding: interfaces.Binding<T>);
+    onActivation(handler: interfaces.BindingActivation<T>): interfaces.BindingWhenSyntax<T>;
+    onDeactivation(handler: interfaces.BindingDeactivation<T>): interfaces.BindingWhenSyntax<T>;
+}
+export { BindingOnSyntax };

package/lib/esm/types/di/syntax/binding_to_syntax.d.ts

@@ -0,0 +1,18 @@
+import { interfaces } from "../interfaces/interfaces.js";
+import { BindingWhenOnSyntax } from "./binding_when_on_syntax.js";
+declare class BindingToSyntax<T> implements interfaces.BindingToSyntax<T> {
+    private _binding;
+    constructor(binding: interfaces.Binding<T>);
+    to(constructor: interfaces.Newable<T>): interfaces.BindingInWhenOnSyntax<T>;
+    toSelf(): interfaces.BindingInWhenOnSyntax<T>;
+    toConstantValue(value: T): interfaces.BindingWhenOnSyntax<T>;
+    toDynamicValue(func: interfaces.DynamicValue<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>;
+    toAutoNamedFactory<T2>(serviceIdentifier: interfaces.ServiceIdentifier<T2>): BindingWhenOnSyntax<T>;
+    toProvider<T2>(provider: interfaces.ProviderCreator<T2>): interfaces.BindingWhenOnSyntax<T>;
+    toService(service: string | symbol | interfaces.Newable<T> | interfaces.Abstract<T>): void;
+}
+export { BindingToSyntax };