@navios/di 0.5.1 → 0.6.1

package/lib/index-7jfWsiG4.d.mts

@@ -0,0 +1,1211 @@
+import { ZodObject, ZodOptional, ZodRecord, ZodType, z } from "zod/v4";
+
+//#region src/utils/types.d.mts
+type Join<TElements, TSeparator extends string> = TElements extends Readonly<[infer First, ...infer Rest]> ? Rest extends ReadonlyArray<string> ? First extends string ? `${First}${Rest extends [] ? '' : TSeparator}${Join<Rest, TSeparator>}` : never : never : '';
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type UnionToOvlds<U> = UnionToIntersection<U extends any ? (f: U) => void : never>;
+type PopUnion<U> = UnionToOvlds<U> extends ((a: infer A) => void) ? A : never;
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+type UnionToArray<T, A extends unknown[] = []> = IsUnion<T> extends true ? UnionToArray<Exclude<T, PopUnion<T>>, [PopUnion<T>, ...A]> : [T, ...A];
+type InjectRequest = {
+  token: InjectionToken<any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any> | ClassType;
+  promise: Promise<any>;
+  readonly result: any;
+  readonly error: Error | null;
+};
+interface InjectState {
+  currentIndex: number;
+  isFrozen: boolean;
+  requests: InjectRequest[];
+}
+//#endregion
+//#region src/interfaces/factory.interface.d.mts
+interface Factorable<T> {
+  create(ctx?: FactoryContext): Promise<T> | T;
+}
+interface FactorableWithArgs<T, A extends InjectionTokenSchemaType> {
+  create(ctx?: FactoryContext, ...args: [z.output<A>]): Promise<T> | T;
+}
+//#endregion
+//#region src/interfaces/container.interface.d.mts
+/**
+ * Interface for dependency injection containers.
+ * Both Container and ScopedContainer implement this interface,
+ * allowing them to be used interchangeably in factory contexts.
+ */
+interface IContainer {
+  /**
+   * Gets an instance from the container.
+   */
+  get<T extends ClassType>(token: T): InstanceType<T> extends Factorable<infer R> ? Promise<R> : Promise<InstanceType<T>>;
+  get<T extends ClassTypeWithArgument<R>, R>(token: T, args: R): Promise<InstanceType<T>>;
+  get<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
+  get<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? Promise<T> : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
+  get<T>(token: InjectionToken<T, undefined>): Promise<T>;
+  get<T>(token: BoundInjectionToken<T, any>): Promise<T>;
+  get<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
+  /**
+   * Invalidates a service and its dependencies.
+   */
+  invalidate(service: unknown): Promise<void>;
+  /**
+   * Checks if a service is registered in the container.
+   */
+  isRegistered(token: any): boolean;
+  /**
+   * Disposes the container and cleans up all resources.
+   */
+  dispose(): Promise<void>;
+  /**
+   * Waits for all pending operations to complete.
+   */
+  ready(): Promise<void>;
+  /**
+   * @internal
+   * Attempts to get an instance synchronously if it already exists.
+   * Returns null if the instance doesn't exist or is not ready.
+   * Used internally by the inject system for synchronous property initialization.
+   */
+  tryGetSync<T>(token: any, args?: any): T | null;
+}
+//#endregion
+//#region src/utils/get-injectors.d.mts
+interface Injectors {
+  asyncInject<T extends ClassTypeWithoutArguments>(token: T): InstanceType<T> extends Factorable<infer R> ? Promise<R> : Promise<InstanceType<T>>;
+  asyncInject<Args, T extends ClassTypeWithArgument<Args>>(token: T, args: Args): Promise<InstanceType<T>>;
+  asyncInject<Schema extends InjectionTokenSchemaType, R, T extends FactorableWithArgs<R, Schema>>(token: T, args: z.input<Schema>): Promise<R>;
+  asyncInject<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
+  asyncInject<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? Promise<T> : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
+  asyncInject<T>(token: InjectionToken<T, undefined>): Promise<T>;
+  asyncInject<T>(token: BoundInjectionToken<T, any>): Promise<T>;
+  asyncInject<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
+  inject<T extends ClassTypeWithoutArguments>(token: T): InstanceType<T> extends Factorable<infer R> ? R : InstanceType<T>;
+  inject<Args, T extends ClassTypeWithArgument<Args>>(token: T, args: Args): InstanceType<T>;
+  inject<Schema extends InjectionTokenSchemaType, R, T extends FactorableWithArgs<R, Schema>>(token: T, args: z.input<Schema>): R;
+  inject<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): T;
+  inject<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? T : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
+  inject<T>(token: InjectionToken<T, undefined>): T;
+  inject<T>(token: BoundInjectionToken<T, any>): T;
+  inject<T>(token: FactoryInjectionToken<T, any>): T;
+  /**
+   * Optional injection that returns null if the service fails to initialize
+   * or is not available. This is useful when you want to inject a service
+   * that may not be configured or may fail gracefully.
+   *
+   * @example
+   * ```ts
+   * class MyService {
+   *   constructor() {
+   *     const optionalService = optional(OptionalServiceToken)
+   *     // optionalService will be null if initialization fails
+   *     if (optionalService) {
+   *       optionalService.doSomething()
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  optional<T extends ClassType>(token: T): (InstanceType<T> extends Factorable<infer R> ? R : InstanceType<T>) | null;
+  optional<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): T | null;
+  optional<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? T | null : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
+  optional<T>(token: InjectionToken<T, undefined>): T | null;
+  optional<T>(token: BoundInjectionToken<T, any>): T | null;
+  optional<T>(token: FactoryInjectionToken<T, any>): T | null;
+  wrapSyncInit(cb: () => any): (injectState?: InjectState) => [any, Promise<any>[], InjectState];
+  provideFactoryContext(context: FactoryContext | null): FactoryContext | null;
+}
+declare function getInjectors(): Injectors;
+//#endregion
+//#region src/utils/get-injectable-token.d.mts
+declare function getInjectableToken<R>(target: ClassType): R extends {
+  create(...args: any[]): infer V;
+} ? InjectionToken<V> : InjectionToken<R>;
+//#endregion
+//#region src/internal/context/factory-context.d.mts
+/**
+ * Context provided to factory functions during service instantiation.
+ *
+ * Provides access to dependency injection (via inject), the container,
+ * and lifecycle hooks for cleanup.
+ */
+interface FactoryContext {
+  inject: Injectors['asyncInject'];
+  /**
+   * The container instance for dependency resolution.
+   * This may be either a Container or ScopedContainer.
+   */
+  container: IContainer;
+  addDestroyListener: (listener: () => void) => void;
+}
+//#endregion
+//#region src/token/injection-token.d.mts
+type ClassType = new (...args: any[]) => any;
+type ClassTypeWithoutArguments = new () => any;
+type ClassTypeWithArgument<Arg> = new (arg: Arg) => any;
+type ClassTypeWithOptionalArgument<Arg> = new (arg?: Arg) => any;
+type ClassTypeWithInstance<T> = new (...args: any[]) => T;
+type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T;
+type ClassTypeWithInstanceAndOptionalArgument<T, Arg> = new (arg?: Arg) => T;
+type BaseInjectionTokenSchemaType = ZodObject | ZodRecord;
+type OptionalInjectionTokenSchemaType = ZodOptional<ZodObject> | ZodOptional<ZodRecord>;
+type InjectionTokenSchemaType = BaseInjectionTokenSchemaType | OptionalInjectionTokenSchemaType;
+declare class InjectionToken<T, S extends InjectionTokenSchemaType | unknown = unknown, Required extends boolean = (S extends ZodOptional<ZodObject> ? false : S extends ZodOptional<ZodRecord> ? false : S extends ZodObject ? true : S extends ZodRecord ? true : false)> {
+  readonly name: string | symbol | ClassType;
+  readonly schema: ZodObject | undefined;
+  id: `${string}-${string}-${string}-${string}-${string}`;
+  private formattedName;
+  constructor(name: string | symbol | ClassType, schema: ZodObject | undefined);
+  static create<T extends ClassType>(name: T): InjectionToken<InstanceType<T>, undefined>;
+  static create<T extends ClassType, Schema extends InjectionTokenSchemaType>(name: T, schema: Schema): Schema['_def']['type'] extends 'ZodOptional' ? InjectionToken<InstanceType<T>, Schema, false> : InjectionToken<InstanceType<T>, Schema, true>;
+  static create<T>(name: string | symbol): InjectionToken<T, undefined>;
+  static create<T, Schema extends InjectionTokenSchemaType>(name: string | any, schema: Schema): InjectionToken<T, Schema>;
+  static bound<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, value: z.input<S>): BoundInjectionToken<T, S>;
+  static factory<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, factory: (ctx: FactoryContext) => Promise<z.input<S>>): FactoryInjectionToken<T, S>;
+  static refineType<T>(token: BoundInjectionToken<any, any>): BoundInjectionToken<T, any>;
+  toString(): string;
+}
+declare class BoundInjectionToken<T, S extends InjectionTokenSchemaType> {
+  readonly token: InjectionToken<T, S>;
+  readonly value: z.input<S>;
+  id: string;
+  name: string | symbol | ClassType;
+  schema: InjectionTokenSchemaType;
+  constructor(token: InjectionToken<T, S>, value: z.input<S>);
+  toString(): string;
+}
+declare class FactoryInjectionToken<T, S extends InjectionTokenSchemaType> {
+  readonly token: InjectionToken<T, S>;
+  readonly factory: (ctx: FactoryContext) => Promise<z.input<S>>;
+  value?: z.input<S>;
+  resolved: boolean;
+  id: string;
+  name: string | symbol | ClassType;
+  schema: InjectionTokenSchemaType;
+  constructor(token: InjectionToken<T, S>, factory: (ctx: FactoryContext) => Promise<z.input<S>>);
+  resolve(ctx: FactoryContext): Promise<z.input<S>>;
+  toString(): string;
+}
+type AnyInjectableType = ClassType | InjectionToken<any, any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>;
+type InjectionTokenType = InjectionToken<any, any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>;
+//#endregion
+//#region src/enums/injectable-scope.enum.d.mts
+declare enum InjectableScope {
+  /**
+   * Singleton scope: The instance is created once and shared across the application.
+   */
+  Singleton = "Singleton",
+  /**
+   * Instance scope: A new instance is created for each injection.
+   */
+  Transient = "Transient",
+  /**
+   * Request scope: The instance is created once per request and shared within that request context.
+   */
+  Request = "Request",
+}
+//#endregion
+//#region src/enums/injectable-type.enum.d.mts
+declare enum InjectableType {
+  Class = "Class",
+  Factory = "Factory",
+}
+//#endregion
+//#region src/token/registry.d.mts
+type FactoryRecord<Instance = any, Schema = any> = {
+  scope: InjectableScope;
+  originalToken: InjectionToken<Instance, Schema>;
+  target: ClassType;
+  type: InjectableType;
+};
+declare class Registry {
+  private readonly parent?;
+  private readonly factories;
+  constructor(parent?: Registry | undefined);
+  has(token: InjectionToken<any, any>): boolean;
+  get<Instance, Schema>(token: InjectionToken<Instance, Schema>): FactoryRecord<Instance, Schema>;
+  set<Instance, Schema>(token: InjectionToken<Instance, Schema>, scope: InjectableScope, target: ClassType, type: InjectableType): void;
+  delete(token: InjectionToken<any, any>): void;
+}
+declare const globalRegistry: Registry;
+//#endregion
+//#region src/errors/di-error.d.mts
+declare enum DIErrorCode {
+  FactoryNotFound = "FactoryNotFound",
+  FactoryTokenNotResolved = "FactoryTokenNotResolved",
+  InstanceNotFound = "InstanceNotFound",
+  InstanceDestroying = "InstanceDestroying",
+  CircularDependency = "CircularDependency",
+  UnknownError = "UnknownError",
+}
+declare class DIError extends Error {
+  readonly code: DIErrorCode;
+  readonly message: string;
+  readonly context?: Record<string, unknown>;
+  constructor(code: DIErrorCode, message: string, context?: Record<string, unknown>);
+  static factoryNotFound(name: string): DIError;
+  static factoryTokenNotResolved(token: string | symbol | unknown): DIError;
+  static instanceNotFound(name: string): DIError;
+  static instanceDestroying(name: string): DIError;
+  static unknown(message: string | Error, context?: Record<string, unknown>): DIError;
+  static circularDependency(cycle: string[]): DIError;
+}
+//#endregion
+//#region src/internal/holder/instance-holder.d.mts
+/**
+ * Represents the lifecycle status of an instance holder.
+ */
+declare enum InstanceStatus {
+  /** Instance has been successfully created and is ready for use */
+  Created = "created",
+  /** Instance is currently being created (async initialization in progress) */
+  Creating = "creating",
+  /** Instance is being destroyed (cleanup in progress) */
+  Destroying = "destroying",
+  /** Instance creation failed with an error */
+  Error = "error",
+}
+/** Callback function for instance effects */
+type InstanceEffect = () => void;
+/** Callback function for instance destruction listeners */
+type InstanceDestroyListener = () => void | Promise<void>;
+/**
+ * Instance holder in the Creating state.
+ * The instance is null while creation is in progress.
+ */
+interface InstanceHolderCreating<Instance> {
+  status: InstanceStatus.Creating;
+  name: string;
+  instance: null;
+  creationPromise: Promise<[undefined, Instance]> | null;
+  destroyPromise: null;
+  type: InjectableType;
+  scope: InjectableScope;
+  deps: Set<string>;
+  destroyListeners: InstanceDestroyListener[];
+  createdAt: number;
+  /** Tracks which services this holder is currently waiting for (for circular dependency detection) */
+  waitingFor: Set<string>;
+}
+/**
+ * Instance holder in the Created state.
+ * The instance is available and ready for use.
+ */
+interface InstanceHolderCreated<Instance> {
+  status: InstanceStatus.Created;
+  name: string;
+  instance: Instance;
+  creationPromise: null;
+  destroyPromise: null;
+  type: InjectableType;
+  scope: InjectableScope;
+  deps: Set<string>;
+  destroyListeners: InstanceDestroyListener[];
+  createdAt: number;
+  /** Tracks which services this holder is currently waiting for (for circular dependency detection) */
+  waitingFor: Set<string>;
+}
+/**
+ * Instance holder in the Destroying state.
+ * The instance may still be available but is being cleaned up.
+ */
+interface InstanceHolderDestroying<Instance> {
+  status: InstanceStatus.Destroying;
+  name: string;
+  instance: Instance | null;
+  creationPromise: null;
+  destroyPromise: Promise<void>;
+  type: InjectableType;
+  scope: InjectableScope;
+  deps: Set<string>;
+  destroyListeners: InstanceDestroyListener[];
+  createdAt: number;
+  /** Tracks which services this holder is currently waiting for (for circular dependency detection) */
+  waitingFor: Set<string>;
+}
+/**
+ * Instance holder in the Error state.
+ * The instance field contains the error that occurred during creation.
+ */
+interface InstanceHolderError {
+  status: InstanceStatus.Error;
+  name: string;
+  instance: Error;
+  creationPromise: null;
+  destroyPromise: null;
+  type: InjectableType;
+  scope: InjectableScope;
+  deps: Set<string>;
+  destroyListeners: InstanceDestroyListener[];
+  createdAt: number;
+  /** Tracks which services this holder is currently waiting for (for circular dependency detection) */
+  waitingFor: Set<string>;
+}
+/**
+ * Holds the state of a service instance throughout its lifecycle.
+ *
+ * Tracks creation/destruction promises, dependency relationships,
+ * destroy listeners, and current status (Creating, Created, Destroying, Error).
+ */
+type InstanceHolder<Instance = unknown> = InstanceHolderCreating<Instance> | InstanceHolderCreated<Instance> | InstanceHolderDestroying<Instance> | InstanceHolderError;
+//#endregion
+//#region src/internal/holder/holder-storage.interface.d.mts
+/**
+ * Result type for holder retrieval operations.
+ * - [undefined, holder] - Holder found successfully
+ * - [DIError, holder?] - Error occurred (holder may be available for waiting)
+ * - null - No holder exists
+ */
+type HolderGetResult<T = unknown> = [undefined, InstanceHolder<T>] | [DIError, InstanceHolder<T>?] | null;
+/**
+ * Interface for abstracting holder storage operations.
+ *
+ * Enables unified instance resolution logic regardless of where
+ * holders are stored (singleton manager, request context, etc.).
+ * This is the key abstraction for the Storage Strategy pattern.
+ */
+interface IHolderStorage {
+  /**
+   * The scope this storage handles.
+   */
+  readonly scope: InjectableScope;
+  /**
+   * Retrieves an existing holder by instance name.
+   *
+   * @param instanceName The unique identifier for the instance
+   * @returns
+   *   - [undefined, holder] if found and ready/creating
+   *   - [DIError, holder?] if found but in error/destroying state
+   *   - null if not found
+   */
+  get<T = unknown>(instanceName: string): HolderGetResult<T>;
+  /**
+   * Stores a holder by instance name.
+   *
+   * @param instanceName The unique identifier for the instance
+   * @param holder The holder to store
+   */
+  set(instanceName: string, holder: InstanceHolder): void;
+  /**
+   * Deletes a holder by instance name.
+   *
+   * @param instanceName The unique identifier for the instance
+   * @returns true if the holder was deleted, false if it didn't exist
+   */
+  delete(instanceName: string): boolean;
+  /**
+   * Creates a new holder in "Creating" state with a deferred promise.
+   * The holder is NOT automatically stored - call set() to store it.
+   *
+   * @param instanceName The unique identifier for the instance
+   * @param type The injectable type
+   * @param deps The set of dependency names
+   * @returns A tuple containing the deferred promise resolver and the holder
+   */
+  createHolder<T>(instanceName: string, type: InjectableType, deps: Set<string>): [ReturnType<typeof Promise.withResolvers<[undefined, T]>>, InstanceHolder<T>];
+  /**
+   * Checks if this storage should be used for the given scope.
+   */
+  handles(scope: InjectableScope): boolean;
+  /**
+   * Gets all instance names in this storage.
+   */
+  getAllNames(): string[];
+  /**
+   * Iterates over all holders with a callback.
+   *
+   * @param callback Function called for each holder with (name, holder)
+   */
+  forEach(callback: (name: string, holder: InstanceHolder) => void): void;
+  /**
+   * Finds a holder by its instance value (reverse lookup).
+   *
+   * @param instance The instance to search for
+   * @returns The holder if found, null otherwise
+   */
+  findByInstance(instance: unknown): InstanceHolder | null;
+  /**
+   * Finds all instance names that depend on the given instance name.
+   *
+   * @param instanceName The instance name to find dependents for
+   * @returns Array of instance names that have this instance as a dependency
+   */
+  findDependents(instanceName: string): string[];
+}
+//#endregion
+//#region src/internal/holder/base-holder-manager.d.mts
+/**
+ * Result type for waitForHolderReady.
+ * Returns either [undefined, holder] on success or [error] on failure.
+ */
+type HolderReadyResult<T> = [undefined, InstanceHolder<T>] | [DIError];
+/**
+ * Abstract base class providing common functionality for managing InstanceHolder objects.
+ *
+ * Provides shared patterns for holder storage, creation, and lifecycle management
+ * used by both singleton (HolderManager) and request-scoped (RequestContext) managers.
+ */
+declare abstract class BaseHolderManager {
+  protected readonly logger: Console | null;
+  protected readonly _holders: Map<string, InstanceHolder>;
+  constructor(logger?: Console | null);
+  /**
+   * Protected getter for accessing the holders map from subclasses.
+   */
+  protected get holders(): Map<string, InstanceHolder>;
+  /**
+   * Abstract method to get a holder by name. Each implementation defines its own return type
+   * based on their specific error handling and validation needs.
+   */
+  abstract get(name: string): any;
+  /**
+   * Abstract method to set a holder by name. Each implementation may have different validation logic.
+   */
+  abstract set(name: string, holder: InstanceHolder): void;
+  /**
+   * Abstract method to check if a holder exists. Each implementation may have different validation logic.
+   */
+  abstract has(name: string): any;
+  /**
+   * Deletes a holder by name.
+   * @param name The name of the holder to delete
+   * @returns true if the holder was deleted, false if it didn't exist
+   */
+  delete(name: string): boolean;
+  /**
+   * Filters holders based on a predicate function.
+   * @param predicate Function to test each holder
+   * @returns A new Map containing only the holders that match the predicate
+   */
+  filter(predicate: (value: InstanceHolder<any>, key: string) => boolean): Map<string, InstanceHolder>;
+  /**
+   * Clears all holders from this manager.
+   */
+  clear(): void;
+  /**
+   * Gets the number of holders currently managed.
+   */
+  size(): number;
+  /**
+   * Creates a new holder with Creating status and a deferred creation promise.
+   * This is useful for creating placeholder holders that can be fulfilled later.
+   * @param name The name of the instance
+   * @param type The injectable type
+   * @param scope The injectable scope
+   * @param deps Optional set of dependencies
+   * @returns A tuple containing the deferred promise and the holder
+   */
+  createCreatingHolder<Instance>(name: string, type: InjectableType, scope: InjectableScope, deps?: Set<string>): [ReturnType<typeof Promise.withResolvers<[undefined, Instance]>>, InstanceHolder<Instance>];
+  /**
+   * Creates a new holder with Created status and an actual instance.
+   * This is useful for creating holders that already have their instance ready.
+   * @param name The name of the instance
+   * @param instance The actual instance to store
+   * @param type The injectable type
+   * @param scope The injectable scope
+   * @param deps Optional set of dependencies
+   * @returns The created holder
+   */
+  protected createCreatedHolder<Instance>(name: string, instance: Instance, type: InjectableType, scope: InjectableScope, deps?: Set<string>): InstanceHolder<Instance>;
+  /**
+   * Gets all holder names currently managed.
+   */
+  getAllNames(): string[];
+  /**
+   * Gets all holders currently managed.
+   */
+  getAllHolders(): InstanceHolder[];
+  /**
+   * Checks if this manager has any holders.
+   */
+  isEmpty(): boolean;
+  /**
+   * Waits for a holder to be ready and returns the appropriate result.
+   * This is a shared utility used by both singleton and request-scoped resolution.
+   *
+   * @param holder The holder to wait for
+   * @param waiterHolder Optional holder that is doing the waiting (for circular dependency detection)
+   * @param getHolder Optional function to retrieve holders by name (required if waiterHolder is provided)
+   * @returns A promise that resolves with [undefined, holder] on success or [DIError] on failure
+   */
+  static waitForHolderReady<T>(holder: InstanceHolder<T>, waiterHolder?: InstanceHolder, getHolder?: (name: string) => InstanceHolder | undefined): Promise<HolderReadyResult<T>>;
+}
+//#endregion
+//#region src/internal/context/request-context.d.mts
+/**
+ * Interface for request context that manages pre-prepared instances for a specific request.
+ *
+ * Provides isolated storage for request-scoped services, enabling efficient
+ * instantiation and cleanup within the lifecycle of a single request.
+ */
+interface RequestContext {
+  /**
+   * Unique identifier for this request context.
+   */
+  readonly requestId: string;
+  /**
+   * Instance holders for request-scoped services.
+   */
+  readonly holders: Map<string, InstanceHolder>;
+  /**
+   * Priority for resolution in FactoryContext.inject method.
+   * Higher values take precedence.
+   */
+  readonly priority: number;
+  /**
+   * Request-specific metadata that can be used during instantiation.
+   */
+  readonly metadata: Map<string, any>;
+  /**
+   * Timestamp when this context was created.
+   */
+  readonly createdAt: number;
+  /**
+   * Adds a pre-prepared instance to this context.
+   */
+  addInstance(instanceName: string, instance: any, holder: InstanceHolder): void;
+  /**
+   * Adds a pre-prepared instance to this context.
+   */
+  addInstance(token: InjectionToken<any, undefined>, instance: any): void;
+  /**
+   * Gets an instance holder from this context.
+   */
+  get(instanceName: string): InstanceHolder | undefined;
+  /**
+   * Sets an instance holder by name.
+   */
+  set(instanceName: string, holder: InstanceHolder): void;
+  /**
+   * Checks if this context has a pre-prepared instance.
+   */
+  has(instanceName: string): boolean;
+  /**
+   * Clears all instances and holders from this context.
+   */
+  clear(): void;
+  /**
+   * Gets metadata value by key.
+   */
+  getMetadata(key: string): any | undefined;
+  /**
+   * Sets metadata value by key.
+   */
+  setMetadata(key: string, value: any): void;
+  /**
+   * Filters holders based on a predicate function.
+   */
+  filter(predicate: (value: InstanceHolder<any>, key: string) => boolean): Map<string, InstanceHolder>;
+  /**
+   * Deletes a holder by name.
+   */
+  delete(name: string): boolean;
+  /**
+   * Gets the number of holders currently managed.
+   */
+  size(): number;
+  /**
+   * Checks if this manager has any holders.
+   */
+  isEmpty(): boolean;
+}
+/** @deprecated Use RequestContext instead */
+type RequestContextHolder = RequestContext;
+/**
+ * Default implementation of RequestContext.
+ *
+ * Extends BaseHolderManager to provide holder management functionality
+ * with request-specific metadata and lifecycle support.
+ */
+declare class DefaultRequestContext extends BaseHolderManager implements RequestContext {
+  readonly requestId: string;
+  readonly priority: number;
+  readonly metadata: Map<string, any>;
+  readonly createdAt: number;
+  constructor(requestId: string, priority?: number, initialMetadata?: Record<string, any>);
+  /**
+   * Public getter for holders to maintain interface compatibility.
+   */
+  get holders(): Map<string, InstanceHolder>;
+  /**
+   * Gets a holder by name. For RequestContext, this is a simple lookup.
+   */
+  get(name: string): InstanceHolder | undefined;
+  /**
+   * Sets a holder by name.
+   */
+  set(name: string, holder: InstanceHolder): void;
+  /**
+   * Checks if a holder exists by name.
+   */
+  has(name: string): boolean;
+  addInstance(instanceName: string | InjectionToken<any, undefined>, instance: any, holder?: InstanceHolder): void;
+  clear(): void;
+  getMetadata(key: string): any | undefined;
+  setMetadata(key: string, value: any): void;
+}
+/**
+ * Creates a new request context with the given parameters.
+ */
+declare function createRequestContext(requestId: string, priority?: number, initialMetadata?: Record<string, any>): RequestContext;
+//#endregion
+//#region src/container/scoped-container.d.mts
+/**
+ * Request-scoped dependency injection container.
+ *
+ * Wraps a parent Container and provides isolated request-scoped instances
+ * while delegating singleton and transient resolution to the parent.
+ * This design eliminates race conditions that can occur with async operations
+ * when multiple requests are processed concurrently.
+ */
+declare class ScopedContainer implements IContainer {
+  private readonly parent;
+  private readonly registry;
+  readonly requestId: string;
+  private readonly requestContextHolder;
+  private readonly holderStorage;
+  private disposed;
+  constructor(parent: Container, registry: Registry, requestId: string, metadata?: Record<string, any>, priority?: number);
+  /**
+   * Gets the request context holder for this scoped container.
+   */
+  getRequestContextHolder(): RequestContext;
+  /**
+   * Gets the holder storage for this scoped container.
+   * Used by InstanceResolver for request-scoped resolution.
+   */
+  getHolderStorage(): IHolderStorage;
+  /**
+   * Gets the request ID for this scoped container.
+   */
+  getRequestId(): string;
+  /**
+   * Gets the parent container.
+   */
+  getParent(): Container;
+  /**
+   * Gets metadata from the request context.
+   */
+  getMetadata(key: string): any | undefined;
+  /**
+   * Sets metadata on the request context.
+   */
+  setMetadata(key: string, value: any): void;
+  /**
+   * Adds a pre-prepared instance to the request context.
+   */
+  addInstance(token: InjectionToken<any, undefined>, instance: any): void;
+  /**
+   * Gets an instance from the container.
+   * Request-scoped services are resolved from this container's context.
+   * All other services are delegated to the parent container.
+   */
+  get<T extends ClassType>(token: T): InstanceType<T> extends Factorable<infer R> ? Promise<R> : Promise<InstanceType<T>>;
+  get<T extends ClassTypeWithArgument<R>, R>(token: T, args: R): Promise<InstanceType<T>>;
+  get<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
+  get<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? Promise<T> : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
+  get<T>(token: InjectionToken<T, undefined>): Promise<T>;
+  get<T>(token: BoundInjectionToken<T, any>): Promise<T>;
+  get<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
+  /**
+   * Invalidates a service and its dependencies.
+   * For request-scoped services, invalidation is handled within this context.
+   */
+  invalidate(service: unknown): Promise<void>;
+  /**
+   * Checks if a service is registered.
+   */
+  isRegistered(token: any): boolean;
+  /**
+   * Disposes this scoped container and cleans up all request-scoped instances.
+   * This is an alias for endRequest() for IContainer compatibility.
+   */
+  dispose(): Promise<void>;
+  /**
+   * Ends the request and cleans up all request-scoped instances.
+   * Uses the invalidation system to properly cascade to dependent singletons.
+   */
+  endRequest(): Promise<void>;
+  /**
+   * Waits for all pending operations to complete.
+   */
+  ready(): Promise<void>;
+  /**
+   * @internal
+   * Attempts to get an instance synchronously if it already exists and is ready.
+   * For request-scoped services, checks this container's context first.
+   * For other services, delegates to the parent container.
+   *
+   * Returns null if the instance doesn't exist or is not yet ready (still creating).
+   */
+  tryGetSync<T>(token: any, args?: any): T | null;
+  /**
+   * Checks if a token is for a request-scoped service.
+   */
+  private isRequestScoped;
+  /**
+   * Resolves a request-scoped service from this container's context.
+   * Uses locking to prevent duplicate initialization during concurrent resolution.
+   */
+  private resolveRequestScoped;
+  /**
+   * Stores an instance in the request context.
+   * Called by Container during request-scoped service resolution.
+   */
+  storeRequestInstance(instanceName: string, instance: any, holder: InstanceHolder): void;
+  /**
+   * Gets an existing instance from the request context.
+   * Called by Container during resolution to check for existing instances.
+   */
+  getRequestInstance(instanceName: string): InstanceHolder | undefined;
+  /**
+   * Generates a prefixed event name for request-scoped services.
+   * Format: {requestId}:{instanceName}
+   */
+  getPrefixedEventName(instanceName: string): string;
+}
+//#endregion
+//#region src/internal/lifecycle/lifecycle-event-bus.d.mts
+/**
+ * Event bus for service lifecycle events (create, destroy, etc.).
+ *
+ * Enables loose coupling between services by allowing them to subscribe
+ * to lifecycle events of their dependencies without direct references.
+ * Used primarily for invalidation cascading.
+ */
+declare class LifecycleEventBus {
+  private readonly logger;
+  private listeners;
+  constructor(logger?: Console | null);
+  on<Event extends string | `pre:${string}` | `post:${string}`>(ns: string, event: Event, listener: (event: Event) => void): () => void;
+  emit(key: string, event: string): Promise<PromiseSettledResult<any>[] | undefined>;
+}
+//#endregion
+//#region src/internal/holder/holder-manager.d.mts
+/**
+ * Manages the storage and retrieval of singleton instance holders.
+ *
+ * Provides CRUD operations and filtering for the holder map.
+ * Handles holder state validation (destroying, error states) on retrieval.
+ */
+declare class HolderManager extends BaseHolderManager {
+  constructor(logger?: Console | null);
+  get(name: string): [DIError, InstanceHolder] | [DIError] | [undefined, InstanceHolder];
+  set(name: string, holder: InstanceHolder): void;
+  has(name: string): [DIError] | [undefined, boolean];
+  /**
+   * Creates a new holder with Created status and stores it.
+   * This is useful for creating holders that already have their instance ready.
+   * @param name The name of the instance
+   * @param instance The actual instance to store
+   * @param type The injectable type
+   * @param scope The injectable scope
+   * @param deps Optional set of dependencies
+   * @returns The created holder
+   */
+  storeCreatedHolder<Instance>(name: string, instance: Instance, type: InjectableType, scope: InjectableScope, deps?: Set<string>): InstanceHolder<Instance>;
+}
+//#endregion
+//#region src/internal/core/invalidator.d.mts
+interface ClearAllOptions {
+  /** Maximum number of invalidation rounds to prevent infinite loops (default: 10) */
+  maxRounds?: number;
+  /** Whether to wait for all services to settle before starting (default: true) */
+  waitForSettlement?: boolean;
+}
+interface InvalidationOptions {
+  /** Whether to emit events after invalidation (default: true for singletons) */
+  emitEvents?: boolean;
+  /** Custom event emitter function */
+  onInvalidated?: (instanceName: string) => Promise<void>;
+  /** Whether to cascade invalidation to dependents (default: true) */
+  cascade?: boolean;
+  /** Internal: tracks services being invalidated in the current call chain to prevent circular loops */
+  _invalidating?: Set<string>;
+}
+/**
+ * Manages graceful service cleanup with dependency-aware invalidation.
+ *
+ * Ensures services are destroyed in the correct order based on their dependencies.
+ * Works with any IHolderStorage implementation, enabling unified invalidation
+ * for both singleton and request-scoped services.
+ */
+declare class Invalidator {
+  private readonly eventBus;
+  private readonly logger;
+  private readonly storage;
+  constructor(manager: HolderManager, eventBus: LifecycleEventBus | null, logger?: Console | null);
+  /**
+   * Invalidates a service and all its dependencies.
+   * Works with the configured storage (singleton by default).
+   */
+  invalidate(service: string, round?: number): Promise<any>;
+  /**
+   * Invalidates a service using a specific storage.
+   * This allows request-scoped invalidation using a RequestStorage.
+   *
+   * @param service The instance name to invalidate
+   * @param storage The storage to use for this invalidation
+   * @param round Current invalidation round (for recursion limiting)
+   * @param options Additional options for invalidation behavior
+   */
+  invalidateWithStorage(service: string, storage: IHolderStorage, round?: number, options?: InvalidationOptions): Promise<void>;
+  /**
+   * Gracefully clears all services using invalidation logic.
+   * This method respects service dependencies and ensures proper cleanup order.
+   * Services that depend on others will be invalidated first, then their dependencies.
+   */
+  clearAll(options?: ClearAllOptions): Promise<void>;
+  /**
+   * Gracefully clears all services in a specific storage.
+   * This allows clearing request-scoped services using a RequestStorage.
+   */
+  clearAllWithStorage(storage: IHolderStorage, options?: ClearAllOptions): Promise<void>;
+  /**
+   * Waits for all services to settle (either created, destroyed, or error state).
+   */
+  ready(): Promise<void>;
+  /**
+   * Waits for all services in a specific storage to settle.
+   */
+  readyWithStorage(storage: IHolderStorage): Promise<void>;
+  /**
+   * Invalidates a single holder using a specific storage.
+   */
+  private invalidateHolderWithStorage;
+  /**
+   * Common invalidation logic for holders based on their status.
+   */
+  private invalidateHolderByStatus;
+  /**
+   * Destroys a holder using a specific storage.
+   */
+  private destroyHolderWithStorage;
+  /**
+   * Waits for a holder to settle (either created, destroyed, or error state).
+   */
+  private waitForHolderToSettle;
+  /**
+   * Clears services with dependency awareness for a specific storage.
+   */
+  private clearServicesWithDependencyAwarenessForStorage;
+  /**
+   * Finds services that are ready to be cleared in the current round.
+   * A service is ready if all its dependencies have already been cleared.
+   */
+  private findServicesReadyForClearingInStorage;
+  /**
+   * Force clears services that couldn't be cleared through normal dependency resolution.
+   * This handles edge cases like circular dependencies.
+   */
+  private forceClearServicesInStorage;
+  /**
+   * Emits events to listeners for instance lifecycle events.
+   */
+  private emitInstanceEvent;
+}
+//#endregion
+//#region src/internal/core/token-processor.d.mts
+/**
+ * Handles token validation, normalization, and instance name generation.
+ *
+ * Provides utilities for resolving tokens to their underlying InjectionToken,
+ * validating arguments against schemas, and generating unique instance identifiers.
+ */
+declare class TokenProcessor {
+  private readonly logger;
+  constructor(logger?: Console | null);
+  /**
+   * Normalizes a token to an InjectionToken.
+   * Handles class constructors by getting their injectable token.
+   *
+   * @param token A class constructor, InjectionToken, BoundInjectionToken, or FactoryInjectionToken
+   * @returns The normalized InjectionTokenType
+   */
+  normalizeToken(token: AnyInjectableType): InjectionTokenType;
+  /**
+   * Gets the underlying "real" token from wrapped tokens.
+   * For BoundInjectionToken and FactoryInjectionToken, returns the wrapped token.
+   * For other tokens, returns the token itself.
+   *
+   * @param token The token to unwrap
+   * @returns The underlying InjectionToken
+   */
+  getRealToken<T = unknown>(token: InjectionTokenType): InjectionToken<T>;
+  /**
+   * Convenience method that normalizes a token and then gets the real token.
+   * Useful for checking registry entries where you need the actual registered token.
+   *
+   * @param token Any injectable type
+   * @returns The underlying InjectionToken
+   */
+  getRegistryToken<T = unknown>(token: AnyInjectableType): InjectionToken<T>;
+  /**
+   * Validates and resolves token arguments, handling factory token resolution and validation.
+   */
+  validateAndResolveTokenArgs(token: AnyInjectableType, args?: any): [DIError | undefined, {
+    actualToken: InjectionTokenType;
+    validatedArgs?: any;
+  }];
+  /**
+   * Generates a unique instance name based on token and arguments.
+   */
+  generateInstanceName(token: InjectionTokenType, args: any): string;
+  /**
+   * Formats a single argument value for instance name generation.
+   */
+  formatArgValue(value: any): string;
+  /**
+   * Creates a factory context for dependency injection during service instantiation.
+   * @param container The container instance (Container or ScopedContainer) for dependency resolution
+   * @param onDependencyResolved Callback when a dependency is resolved, receives the instance name
+   */
+  createFactoryContext(container: IContainer, onDependencyResolved?: (instanceName: string) => void): FactoryContext & {
+    getDestroyListeners: () => (() => void)[];
+    deps: Set<string>;
+  };
+}
+//#endregion
+//#region src/internal/core/service-locator.d.mts
+/**
+ * Core DI engine that coordinates service instantiation, resolution, and lifecycle.
+ *
+ * Acts as the central orchestrator for dependency injection operations,
+ * delegating to specialized components (InstanceResolver, Instantiator, Invalidator)
+ * for specific tasks.
+ */
+declare class ServiceLocator {
+  private readonly registry;
+  private readonly logger;
+  private readonly injectors;
+  private readonly eventBus;
+  private readonly manager;
+  private readonly instantiator;
+  private readonly tokenProcessor;
+  private readonly invalidator;
+  private readonly instanceResolver;
+  constructor(registry?: Registry, logger?: Console | null, injectors?: Injectors);
+  getEventBus(): LifecycleEventBus;
+  getManager(): HolderManager;
+  getInvalidator(): Invalidator;
+  getTokenProcessor(): TokenProcessor;
+  getInstanceIdentifier(token: AnyInjectableType, args?: any): string;
+  /**
+   * Gets or creates an instance for the given token.
+   * @param token The injection token
+   * @param args Optional arguments
+   * @param contextContainer The container to use for creating FactoryContext
+   */
+  getInstance(token: AnyInjectableType, args: any, contextContainer: IContainer): Promise<any[]>;
+  /**
+   * Gets or throws an instance for the given token.
+   * @param token The injection token
+   * @param args Optional arguments
+   * @param contextContainer The container to use for creating FactoryContext
+   */
+  getOrThrowInstance<Instance>(token: AnyInjectableType, args: any, contextContainer: IContainer): Promise<Instance>;
+  /**
+   * Resolves a request-scoped service for a ScopedContainer.
+   * The service will be stored in the ScopedContainer's request context.
+   *
+   * @param token The injection token
+   * @param args Optional arguments
+   * @param scopedContainer The ScopedContainer that owns the request context
+   */
+  resolveRequestScoped(token: AnyInjectableType, args: any, scopedContainer: ScopedContainer): Promise<any>;
+  getSyncInstance<Instance, Schema extends InjectionTokenSchemaType | undefined>(token: AnyInjectableType, args: Schema extends ZodObject ? z.input<Schema> : Schema extends ZodOptional<ZodObject> ? z.input<Schema> | undefined : undefined, contextContainer: IContainer): Instance | null;
+  invalidate(service: string, round?: number): Promise<any>;
+  /**
+   * Gracefully clears all services in the ServiceLocator using invalidation logic.
+   * This method respects service dependencies and ensures proper cleanup order.
+   * Services that depend on others will be invalidated first, then their dependencies.
+   *
+   * @param options Optional configuration for the clearing process
+   * @returns Promise that resolves when all services have been cleared
+   */
+  clearAll(options?: ClearAllOptions): Promise<void>;
+  /**
+   * Waits for all services to settle (either created, destroyed, or error state).
+   */
+  ready(): Promise<void>;
+  /**
+   * Helper method for InstanceResolver to generate instance names.
+   * This is needed for the factory context creation.
+   */
+  generateInstanceName(token: any, args: any): string;
+}
+//#endregion
+//#region src/container/container.d.mts
+/**
+ * Main dependency injection container.
+ *
+ * Provides a simplified public API for dependency injection, wrapping
+ * a ServiceLocator instance. Handles singleton and transient services directly,
+ * while request-scoped services require using beginRequest() to create a ScopedContainer.
+ */
+declare class Container implements IContainer {
+  protected readonly registry: Registry;
+  protected readonly logger: Console | null;
+  protected readonly injectors: Injectors;
+  private readonly serviceLocator;
+  private readonly activeRequestIds;
+  constructor(registry?: Registry, logger?: Console | null, injectors?: Injectors);
+  private registerSelf;
+  /**
+   * Gets an instance from the container.
+   * This method has the same type signature as the inject method from get-injectors.mts
+   *
+   * NOTE: Request-scoped services cannot be resolved directly from Container.
+   * Use beginRequest() to create a ScopedContainer for request-scoped services.
+   */
+  get<T extends ClassType>(token: T): InstanceType<T> extends Factorable<infer R> ? Promise<R> : Promise<InstanceType<T>>;
+  get<T extends ClassTypeWithArgument<R>, R>(token: T, args: R): Promise<InstanceType<T>>;
+  get<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
+  get<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? Promise<T> : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
+  get<T>(token: InjectionToken<T, undefined>): Promise<T>;
+  get<T>(token: BoundInjectionToken<T, any>): Promise<T>;
+  get<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
+  /**
+   * Gets an instance with a specific container context.
+   * Used by ScopedContainer to delegate singleton/transient resolution
+   * while maintaining the correct container context for nested inject() calls.
+   *
+   * @internal
+   */
+  getWithContext(token: ClassType | InjectionToken<any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>, args: unknown, contextContainer: IContainer): Promise<any>;
+  /**
+   * Resolves a request-scoped service for a ScopedContainer.
+   * The service will be stored in the ScopedContainer's request context.
+   *
+   * @internal
+   */
+  resolveForRequest(token: ClassType | InjectionToken<any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>, args: unknown, scopedContainer: ScopedContainer): Promise<any>;
+  /**
+   * Gets the underlying ServiceLocator instance for advanced usage
+   */
+  getServiceLocator(): ServiceLocator;
+  /**
+   * Gets the registry
+   */
+  getRegistry(): Registry;
+  /**
+   * Invalidates a service and its dependencies
+   */
+  invalidate(service: unknown): Promise<void>;
+  /**
+   * Gets a service holder by instance (reverse lookup)
+   */
+  private getHolderByInstance;
+  /**
+   * Checks if a service is registered in the container
+   */
+  isRegistered(token: any): boolean;
+  /**
+   * Disposes the container and cleans up all resources
+   */
+  dispose(): Promise<void>;
+  /**
+   * Waits for all pending operations to complete
+   */
+  ready(): Promise<void>;
+  /**
+   * @internal
+   * Attempts to get an instance synchronously if it already exists.
+   * Returns null if the instance doesn't exist or is not ready.
+   */
+  tryGetSync<T>(token: any, args?: any): T | null;
+  /**
+   * Begins a new request context and returns a ScopedContainer.
+   *
+   * The ScopedContainer provides isolated request-scoped service resolution
+   * while delegating singleton and transient services to this Container.
+   *
+   * @param requestId Unique identifier for this request
+   * @param metadata Optional metadata for the request
+   * @param priority Priority for resolution (higher = more priority)
+   * @returns A ScopedContainer for this request
+   */
+  beginRequest(requestId: string, metadata?: Record<string, any>, priority?: number): ScopedContainer;
+  /**
+   * Removes a request ID from the active set.
+   * Called by ScopedContainer when the request ends.
+   *
+   * @internal
+   */
+  removeActiveRequest(requestId: string): void;
+  /**
+   * Gets the set of active request IDs.
+   */
+  getActiveRequestIds(): ReadonlySet<string>;
+  /**
+   * Checks if a request ID is currently active.
+   */
+  hasActiveRequest(requestId: string): boolean;
+  /**
+   * Clears all instances and bindings from the container.
+   * This is useful for testing or resetting the container state.
+   */
+  clear(): Promise<void>;
+}
+//#endregion
+//#region src/testing/test-container.d.mts
+/**
+ * A binding builder for the TestContainer that allows chaining binding operations.
+ */
+declare class TestBindingBuilder<T> {
+  private readonly container;
+  private readonly token;
+  constructor(container: TestContainer, token: InjectionToken<T, any>);
+  /**
+   * Binds the token to a specific value.
+   * This is useful for testing with mock values or constants.
+   * @param value The value to bind to the token
+   */
+  toValue(value: T): TestContainer;
+  /**
+   * Binds the token to a class constructor.
+   * @param target The class constructor to bind to
+   */
+  toClass(target: ClassType): TestContainer;
+}
+/**
+ * TestContainer extends the base Container with additional methods useful for testing.
+ * It provides a simplified API for binding values and classes during test setup.
+ */
+declare class TestContainer extends Container {
+  constructor(registry?: Registry, logger?: Console | null, injectors?: Injectors);
+  /**
+   * Creates a binding builder for the given token.
+   * This allows chaining binding operations like bind(Token).toValue(value).
+   * @param token The injection token to bind
+   * @returns A TestBindingBuilder for chaining binding operations
+   */
+  bind<T>(token: ClassType): TestBindingBuilder<T>;
+  bind<T>(token: InjectionToken<T, any>): TestBindingBuilder<T>;
+  /**
+   * Binds a value directly to a token.
+   * This is a convenience method equivalent to bind(token).toValue(value).
+   * @param token The injection token to bind
+   * @param value The value to bind to the token
+   * @returns The TestContainer instance for chaining
+   */
+  bindValue<T>(token: ClassType, value: T): TestContainer;
+  bindValue<T>(token: InjectionToken<T, any>, value: T): TestContainer;
+  /**
+   * Binds a class to a token.
+   * This is a convenience method equivalent to bind(token).toClass(target).
+   * @param token The injection token to bind
+   * @param target The class constructor to bind to
+   * @returns The TestContainer instance for chaining
+   */
+  bindClass(token: ClassType, target: ClassType): TestContainer;
+  bindClass<T>(token: InjectionToken<T, any>, target: ClassType): TestContainer;
+  /**
+   * Creates a new TestContainer instance with the same configuration.
+   * This is useful for creating isolated test containers.
+   * @returns A new TestContainer instance
+   */
+  createChild(): TestContainer;
+}
+//#endregion
+export { Factorable as $, globalRegistry as A, ClassTypeWithInstanceAndOptionalArgument as B, InstanceHolderDestroying as C, DIErrorCode as D, DIError as E, BoundInjectionToken as F, InjectionTokenSchemaType as G, ClassTypeWithoutArguments as H, ClassType as I, FactoryContext as J, InjectionTokenType as K, ClassTypeWithArgument as L, InjectableScope as M, AnyInjectableType as N, FactoryRecord as O, BaseInjectionTokenSchemaType as P, IContainer as Q, ClassTypeWithInstance as R, InstanceHolderCreating as S, InstanceStatus as T, FactoryInjectionToken as U, ClassTypeWithOptionalArgument as V, InjectionToken as W, Injectors as X, getInjectableToken as Y, getInjectors as Z, IHolderStorage as _, TokenProcessor as a, PopUnion as at, InstanceHolder as b, LifecycleEventBus as c, UnionToOvlds as ct, RequestContext as d, FactorableWithArgs as et, RequestContextHolder as f, HolderGetResult as g, HolderReadyResult as h, ServiceLocator as i, Join as it, InjectableType as j, Registry as k, ScopedContainer as l, BaseHolderManager as m, TestContainer as n, InjectState as nt, Invalidator as o, UnionToArray as ot, createRequestContext as p, OptionalInjectionTokenSchemaType as q, Container as r, IsUnion as rt, HolderManager as s, UnionToIntersection as st, TestBindingBuilder as t, InjectRequest as tt, DefaultRequestContext as u, InstanceDestroyListener as v, InstanceHolderError as w, InstanceHolderCreated as x, InstanceEffect as y, ClassTypeWithInstanceAndArgument as z };
+//# sourceMappingURL=index-7jfWsiG4.d.mts.map