@navios/di 0.5.1 → 0.6.0

package/lib/_tsup-dts-rollup.d.ts

@@ -1,1283 +0,0 @@
-import { z } from 'zod/v4';
-import type { ZodObject } from 'zod/v4';
-import type { ZodOptional } from 'zod/v4';
-import type { ZodRecord } from 'zod/v4';
-import type { ZodType } from 'zod/v4';
-
-declare type AnyInjectableType = ClassType | InjectionToken<any, any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>;
-export { AnyInjectableType }
-export { AnyInjectableType as AnyInjectableType_alias_1 }
-
-declare const asyncInject: Injectors['asyncInject'];
-export { asyncInject }
-export { asyncInject as asyncInject_alias_1 }
-
-declare type BaseInjectionTokenSchemaType = ZodObject | ZodRecord;
-export { BaseInjectionTokenSchemaType }
-export { BaseInjectionTokenSchemaType as BaseInjectionTokenSchemaType_alias_1 }
-
-/**
- * Abstract base class that provides common functionality for managing ServiceLocatorInstanceHolder objects.
- * This class contains shared patterns used by both RequestContextHolder and ServiceLocatorManager.
- */
-declare abstract class BaseInstanceHolderManager {
-    protected readonly logger: Console | null;
-    protected readonly _holders: Map<string, ServiceLocatorInstanceHolder>;
-    constructor(logger?: Console | null);
-    /**
-     * Protected getter for accessing the holders map from subclasses.
-     */
-    protected get holders(): Map<string, ServiceLocatorInstanceHolder>;
-    /**
-     * 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: ServiceLocatorInstanceHolder): 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: ServiceLocatorInstanceHolder<any>, key: string) => boolean): Map<string, ServiceLocatorInstanceHolder>;
-    /**
-     * 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]>>,
-    ServiceLocatorInstanceHolder<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>): ServiceLocatorInstanceHolder<Instance>;
-    /**
-     * Gets all holder names currently managed.
-     */
-    getAllNames(): string[];
-    /**
-     * Gets all holders currently managed.
-     */
-    getAllHolders(): ServiceLocatorInstanceHolder[];
-    /**
-     * Checks if this manager has any holders.
-     */
-    isEmpty(): boolean;
-}
-export { BaseInstanceHolderManager }
-export { BaseInstanceHolderManager as BaseInstanceHolderManager_alias_1 }
-
-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;
-}
-export { BoundInjectionToken }
-export { BoundInjectionToken as BoundInjectionToken_alias_1 }
-
-declare type ChannelEmitter<Events extends EventsConfig, Ns extends string, E extends EventsNames<Events>> = {
-    emit<Args extends EventsArgs<Events, E>>(ns: Ns, event: E, ...args: Args): Promise<any>;
-};
-export { ChannelEmitter }
-export { ChannelEmitter as ChannelEmitter_alias_1 }
-
-declare type ClassType = new (...args: any[]) => any;
-export { ClassType }
-export { ClassType as ClassType_alias_1 }
-
-declare type ClassTypeWithArgument<Arg> = new (arg: Arg) => any;
-export { ClassTypeWithArgument }
-export { ClassTypeWithArgument as ClassTypeWithArgument_alias_1 }
-
-declare type ClassTypeWithInstance<T> = new (...args: any[]) => T;
-export { ClassTypeWithInstance }
-export { ClassTypeWithInstance as ClassTypeWithInstance_alias_1 }
-
-declare type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T;
-export { ClassTypeWithInstanceAndArgument }
-export { ClassTypeWithInstanceAndArgument as ClassTypeWithInstanceAndArgument_alias_1 }
-
-declare type ClassTypeWithInstanceAndOptionalArgument<T, Arg> = new (arg?: Arg) => T;
-export { ClassTypeWithInstanceAndOptionalArgument }
-export { ClassTypeWithInstanceAndOptionalArgument as ClassTypeWithInstanceAndOptionalArgument_alias_1 }
-
-declare type ClassTypeWithOptionalArgument<Arg> = new (arg?: Arg) => any;
-export { ClassTypeWithOptionalArgument }
-export { ClassTypeWithOptionalArgument as ClassTypeWithOptionalArgument_alias_1 }
-
-declare type ClassTypeWithoutArguments = new () => any;
-export { ClassTypeWithoutArguments }
-export { ClassTypeWithoutArguments as ClassTypeWithoutArguments_alias_1 }
-
-export declare interface ClearAllOptions {
-    /** Whether to also clear request contexts (default: true) */
-    clearRequestContexts?: boolean;
-    /** 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;
-}
-
-/**
- * Container class that provides a simplified public API for dependency injection.
- * It wraps a ServiceLocator instance and provides convenient methods for getting instances.
- */
-declare class Container {
-    protected readonly registry: Registry;
-    protected readonly logger: Console | null;
-    protected readonly injectors: Injectors;
-    private readonly serviceLocator;
-    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
-     */
-    get<T extends ClassType>(token: T): InstanceType<T> extends Factorable<infer R> ? Promise<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 the underlying ServiceLocator instance for advanced usage
-     */
-    getServiceLocator(): ServiceLocator;
-    /**
-     * Invalidates a service and its dependencies
-     */
-    invalidate(service: unknown): Promise<void>;
-    /**
-     * Gets a service holder by instance (reverse lookup)
-     */
-    private getHolderByInstance;
-    private getRequestHolderByInstance;
-    /**
-     * 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>;
-    /**
-     * Begins a new request context with the given parameters.
-     * @param requestId Unique identifier for this request
-     * @param metadata Optional metadata for the request
-     * @param priority Priority for resolution (higher = more priority)
-     * @returns The created request context holder
-     */
-    beginRequest(requestId: string, metadata?: Record<string, any>, priority?: number): RequestContextHolder;
-    /**
-     * Ends a request context and cleans up all associated instances.
-     * @param requestId The request ID to end
-     */
-    endRequest(requestId: string): Promise<void>;
-    /**
-     * Gets the current request context.
-     * @returns The current request context holder or null
-     */
-    getCurrentRequestContext(): RequestContextHolder | null;
-    /**
-     * Sets the current request context.
-     * @param requestId The request ID to set as current
-     */
-    setCurrentRequestContext(requestId: string): void;
-    /**
-     * Clears all instances and bindings from the container.
-     * This is useful for testing or resetting the container state.
-     */
-    clear(): Promise<void>;
-}
-export { Container }
-export { Container as Container_alias_1 }
-
-/**
- * Creates a new request context holder with the given parameters.
- */
-declare function createRequestContextHolder(requestId: string, priority?: number, initialMetadata?: Record<string, any>): RequestContextHolder;
-export { createRequestContextHolder }
-export { createRequestContextHolder as createRequestContextHolder_alias_1 }
-
-declare const defaultInjectors: Injectors;
-export { defaultInjectors }
-export { defaultInjectors as defaultInjectors_alias_1 }
-
-/**
- * Default implementation of RequestContextHolder.
- */
-declare class DefaultRequestContextHolder extends BaseInstanceHolderManager implements RequestContextHolder {
-    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, ServiceLocatorInstanceHolder>;
-    /**
-     * Gets a holder by name. For RequestContextHolder, this is a simple lookup.
-     */
-    get(name: string): ServiceLocatorInstanceHolder | undefined;
-    /**
-     * Sets a holder by name.
-     */
-    set(name: string, holder: ServiceLocatorInstanceHolder): void;
-    /**
-     * Checks if a holder exists by name.
-     */
-    has(name: string): boolean;
-    addInstance(instanceName: string | InjectionToken<any, undefined>, instance: any, holder?: ServiceLocatorInstanceHolder): void;
-    clear(): void;
-    getMetadata(key: string): any | undefined;
-    setMetadata(key: string, value: any): void;
-}
-export { DefaultRequestContextHolder }
-export { DefaultRequestContextHolder as DefaultRequestContextHolder_alias_1 }
-
-declare class DIError extends Error {
-    readonly code: DIErrorCode;
-    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;
-}
-export { DIError }
-export { DIError as DIError_alias_1 }
-export { DIError as DIError_alias_2 }
-export { DIError as FactoryNotFound }
-export { DIError as FactoryNotFound_alias_1 }
-export { DIError as FactoryTokenNotResolved }
-export { DIError as FactoryTokenNotResolved_alias_1 }
-export { DIError as InstanceDestroying }
-export { DIError as InstanceDestroying_alias_1 }
-export { DIError as InstanceNotFound }
-export { DIError as InstanceNotFound_alias_1 }
-export { DIError as UnknownError }
-export { DIError as UnknownError_alias_1 }
-
-declare enum DIErrorCode {
-    FactoryNotFound = "FactoryNotFound",
-    FactoryTokenNotResolved = "FactoryTokenNotResolved",
-    InstanceNotFound = "InstanceNotFound",
-    InstanceDestroying = "InstanceDestroying",
-    UnknownError = "UnknownError"
-}
-export { DIErrorCode }
-export { DIErrorCode as DIErrorCode_alias_1 }
-export { DIErrorCode as DIErrorCode_alias_2 }
-export { DIErrorCode as ErrorsEnum }
-export { DIErrorCode as ErrorsEnum_alias_1 }
-
-declare class EventEmitter<Events extends EventsConfig = {}> implements EventEmitterInterface<Events> {
-    private listeners;
-    on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void | Promise<void>): () => void;
-    off<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void | Promise<void>): void;
-    once<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void | Promise<void>): () => void;
-    emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, ...args: Args): Promise<any>;
-}
-export { EventEmitter }
-export { EventEmitter as EventEmitter_alias_1 }
-
-declare interface EventEmitterInterface<Events extends EventsConfig> {
-    on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void | Promise<void>): () => void;
-    emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, ...args: Args): void | Promise<void>;
-}
-export { EventEmitterInterface }
-export { EventEmitterInterface as EventEmitterInterface_alias_1 }
-
-declare type EventsArgs<Events extends EventsConfig, Name extends EventsNames<Events>> = Events[Name] extends any[] ? Events[Name] : [];
-export { EventsArgs }
-export { EventsArgs as EventsArgs_alias_1 }
-
-declare type EventsConfig = {
-    [event: string]: any[];
-};
-export { EventsConfig }
-export { EventsConfig as EventsConfig_alias_1 }
-
-declare type EventsNames<Events extends EventsConfig> = Exclude<keyof Events, symbol | number>;
-export { EventsNames }
-export { EventsNames as EventsNames_alias_1 }
-
-declare interface Factorable<T> {
-    create(ctx?: FactoryContext): Promise<T> | T;
-}
-export { Factorable }
-export { Factorable as Factorable_alias_1 }
-export { Factorable as Factorable_alias_2 }
-
-declare interface FactorableWithArgs<T, A extends InjectionTokenSchemaType> {
-    create(ctx?: FactoryContext, ...args: [z.output<A>]): Promise<T> | T;
-}
-export { FactorableWithArgs }
-export { FactorableWithArgs as FactorableWithArgs_alias_1 }
-export { FactorableWithArgs as FactorableWithArgs_alias_2 }
-
-declare function Factory<R>(options?: {
-    scope?: InjectableScope;
-    registry?: Registry;
-}): <T extends ClassTypeWithInstance<Factorable<R>>>(target: T, context?: ClassDecoratorContext) => T;
-
-declare function Factory<R, S>(options: {
-    scope?: InjectableScope;
-    token: InjectionToken<R, S>;
-    registry?: Registry;
-}): R extends undefined ? never : S extends InjectionTokenSchemaType ? <T extends ClassTypeWithInstance<FactorableWithArgs<R, S>>>(// #2.2.1 Token have a schema
-target: T, context?: ClassDecoratorContext) => T : S extends undefined ? <T extends ClassTypeWithInstance<Factorable<R>>>(// #2.3.1 Token without a schema
-target: T, context?: ClassDecoratorContext) => T : never;
-export { Factory }
-export { Factory as Factory_alias_1 }
-export { Factory as Factory_alias_2 }
-
-declare interface FactoryContext {
-    inject: Injectors['asyncInject'];
-    locator: ServiceLocator;
-    addDestroyListener: (listener: () => void) => void;
-}
-export { FactoryContext }
-export { FactoryContext as FactoryContext_alias_1 }
-
-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;
-}
-export { FactoryInjectionToken }
-export { FactoryInjectionToken as FactoryInjectionToken_alias_1 }
-
-declare interface FactoryOptions {
-    scope?: InjectableScope;
-    token?: InjectionToken<any, any>;
-    registry?: Registry;
-}
-export { FactoryOptions }
-export { FactoryOptions as FactoryOptions_alias_1 }
-export { FactoryOptions as FactoryOptions_alias_2 }
-
-declare type FactoryRecord<Instance = any, Schema = any> = {
-    scope: InjectableScope;
-    originalToken: InjectionToken<Instance, Schema>;
-    target: ClassType;
-    type: InjectableType;
-};
-export { FactoryRecord }
-export { FactoryRecord as FactoryRecord_alias_1 }
-
-declare function getInjectableToken<R>(target: ClassType): R extends {
-    create(...args: any[]): infer V;
-} ? InjectionToken<V> : InjectionToken<R>;
-export { getInjectableToken }
-export { getInjectableToken as getInjectableToken_alias_1 }
-export { getInjectableToken as getInjectableToken_alias_2 }
-
-declare function getInjectors(): Injectors;
-export { getInjectors }
-export { getInjectors as getInjectors_alias_1 }
-export { getInjectors as getInjectors_alias_2 }
-
-declare const globalRegistry: Registry;
-export { globalRegistry }
-export { globalRegistry as globalRegistry_alias_1 }
-
-declare const inject: Injectors['inject'];
-export { inject }
-export { inject as inject_alias_1 }
-
-declare function Injectable(): <T extends ClassTypeWithoutArguments>(target: T, context?: ClassDecoratorContext) => T;
-
-declare function Injectable(options: {
-    scope?: InjectableScope;
-    registry: Registry;
-}): <T extends ClassTypeWithoutArguments>(target: T, context?: ClassDecoratorContext) => T;
-
-declare function Injectable(options: {
-    scope: InjectableScope;
-}): <T extends ClassTypeWithoutArguments>(target: T, context?: ClassDecoratorContext) => T;
-
-declare function Injectable<Schema extends InjectionTokenSchemaType>(options: {
-    scope?: InjectableScope;
-    schema: Schema;
-    registry?: Registry;
-}): <T extends ClassTypeWithArgument<z.output<Schema>>>(target: T, context?: ClassDecoratorContext) => T;
-
-declare function Injectable<Type, Schema>(options: {
-    scope?: InjectableScope;
-    token: InjectionToken<Type, Schema>;
-    registry?: Registry;
-}): Schema extends BaseInjectionTokenSchemaType ? Type extends undefined ? <T extends ClassTypeWithArgument<z.output<Schema>>>(// #3.1.1 Typeless token
-target: T, context?: ClassDecoratorContext) => T : <T extends ClassTypeWithInstanceAndArgument<Type, z.output<Schema>>>(// #3.1.2 Typed token
-target: T, context?: ClassDecoratorContext) => T : Schema extends OptionalInjectionTokenSchemaType ? Type extends undefined ? <T extends ClassTypeWithOptionalArgument<z.output<Schema>>>(// #3.2.1 Typeless token
-target: T, context?: ClassDecoratorContext) => T : <T extends ClassTypeWithInstanceAndOptionalArgument<Type, z.output<Schema>>>(target: T, context?: ClassDecoratorContext) => T : Schema extends undefined ? <R extends ClassTypeWithInstance<Type>>(// #3.3.1 Token must have a type
-target: R, context?: ClassDecoratorContext) => R : never;
-export { Injectable }
-export { Injectable as Injectable_alias_1 }
-export { Injectable as Injectable_alias_2 }
-
-declare interface InjectableOptions {
-    scope?: InjectableScope;
-    token?: InjectionToken<any, any>;
-    schema?: InjectionTokenSchemaType;
-    registry?: Registry;
-}
-export { InjectableOptions }
-export { InjectableOptions as InjectableOptions_alias_1 }
-export { InjectableOptions as InjectableOptions_alias_2 }
-
-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"
-}
-export { InjectableScope }
-export { InjectableScope as InjectableScope_alias_1 }
-export { InjectableScope as InjectableScope_alias_2 }
-
-declare const InjectableTokenMeta: unique symbol;
-export { InjectableTokenMeta }
-export { InjectableTokenMeta as InjectableTokenMeta_alias_1 }
-export { InjectableTokenMeta as InjectableTokenMeta_alias_2 }
-
-declare enum InjectableType {
-    Class = "Class",
-    Factory = "Factory"
-}
-export { InjectableType }
-export { InjectableType as InjectableType_alias_1 }
-export { InjectableType as InjectableType_alias_2 }
-
-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;
-}
-export { InjectionToken }
-export { InjectionToken as InjectionToken_alias_1 }
-
-declare type InjectionTokenSchemaType = BaseInjectionTokenSchemaType | OptionalInjectionTokenSchemaType;
-export { InjectionTokenSchemaType }
-export { InjectionTokenSchemaType as InjectionTokenSchemaType_alias_1 }
-
-declare type InjectionTokenType = InjectionToken<any, any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>;
-export { InjectionTokenType }
-export { InjectionTokenType as InjectionTokenType_alias_1 }
-
-declare 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;
-}
-export { Injectors }
-export { Injectors as Injectors_alias_1 }
-export { Injectors as Injectors_alias_2 }
-
-declare type InjectRequest = {
-    token: InjectionToken<any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any> | ClassType;
-    promise: Promise<any>;
-    readonly result: any;
-    readonly error: Error | null;
-};
-export { InjectRequest }
-export { InjectRequest as InjectRequest_alias_1 }
-export { InjectRequest as InjectRequest_alias_2 }
-
-declare interface InjectState {
-    currentIndex: number;
-    isFrozen: boolean;
-    requests: InjectRequest[];
-}
-export { InjectState }
-export { InjectState as InjectState_alias_1 }
-export { InjectState as InjectState_alias_2 }
-
-/**
- * InstanceResolver handles instance resolution, creation, and lifecycle management.
- * Extracted from ServiceLocator to improve separation of concerns.
- */
-export declare class InstanceResolver {
-    private readonly registry;
-    private readonly manager;
-    private readonly serviceInstantiator;
-    private readonly tokenProcessor;
-    private readonly logger;
-    private readonly serviceLocator;
-    constructor(registry: Registry, manager: ServiceLocatorManager, serviceInstantiator: ServiceInstantiator, tokenProcessor: TokenProcessor, logger: (Console | null) | undefined, serviceLocator: ServiceLocator);
-    /**
-     * Resolves an instance for the given token and arguments.
-     */
-    resolveInstance(token: AnyInjectableType, args?: any, requestContext?: RequestContextHolder): Promise<[undefined, any] | [DIError]>;
-    /**
-     * Gets a synchronous instance (for sync operations).
-     */
-    getSyncInstance<Instance, Schema extends InjectionTokenSchemaType | undefined>(token: AnyInjectableType, args: Schema extends ZodObject ? z.input<Schema> : Schema extends ZodOptional<ZodObject> ? z.input<Schema> | undefined : undefined, currentRequestContext: RequestContextHolder | null): Instance | null;
-    /**
-     * Internal method to resolve token args and create instance name.
-     * Handles factory token resolution and validation.
-     */
-    private resolveTokenAndPrepareInstanceName;
-    /**
-     * Gets an instance by its instance name, handling all the logic after instance name creation.
-     */
-    private retrieveOrCreateInstanceByInstanceName;
-    /**
-     * Attempts to retrieve an existing instance, handling request-scoped and singleton instances.
-     * Returns null if no instance exists and a new one should be created.
-     */
-    private tryGetExistingInstance;
-    /**
-     * Attempts to get a request-scoped instance if applicable.
-     */
-    private tryGetRequestScopedInstance;
-    /**
-     * Attempts to get a singleton instance from the manager.
-     */
-    private tryGetSingletonInstance;
-    /**
-     * Waits for an instance holder to be ready and returns the appropriate result.
-     */
-    private waitForInstanceReady;
-    /**
-     * Creates a new instance for the given token and arguments.
-     */
-    private createNewInstance;
-    /**
-     * Instantiates a service from the registry using the service instantiator.
-     */
-    private instantiateServiceFromRegistry;
-    /**
-     * Handles the result of service instantiation.
-     */
-    private handleInstantiationResult;
-    /**
-     * Handles successful service instantiation.
-     */
-    private handleInstantiationSuccess;
-    /**
-     * Handles service instantiation errors.
-     */
-    private handleInstantiationError;
-    /**
-     * Stores an instance holder based on its scope.
-     */
-    private storeInstanceByScope;
-    /**
-     * Creates a factory context for dependency injection during service instantiation.
-     */
-    private createFactoryContext;
-}
-
-declare type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
-export { IsUnion }
-export { IsUnion as IsUnion_alias_1 }
-export { IsUnion as IsUnion_alias_2 }
-
-declare 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 : '';
-export { Join }
-export { Join as Join_alias_1 }
-export { Join as Join_alias_2 }
-
-declare interface OnServiceDestroy {
-    onServiceDestroy(): Promise<void> | void;
-}
-export { OnServiceDestroy }
-export { OnServiceDestroy as OnServiceDestroy_alias_1 }
-export { OnServiceDestroy as OnServiceDestroy_alias_2 }
-
-declare interface OnServiceInit {
-    onServiceInit(): Promise<void> | void;
-}
-export { OnServiceInit }
-export { OnServiceInit as OnServiceInit_alias_1 }
-export { OnServiceInit as OnServiceInit_alias_2 }
-
-declare const optional: Injectors['optional'];
-export { optional }
-export { optional as optional_alias_1 }
-
-declare type OptionalInjectionTokenSchemaType = ZodOptional<ZodObject> | ZodOptional<ZodRecord>;
-export { OptionalInjectionTokenSchemaType }
-export { OptionalInjectionTokenSchemaType as OptionalInjectionTokenSchemaType_alias_1 }
-
-declare type PopUnion<U> = UnionToOvlds<U> extends (a: infer A) => void ? A : never;
-export { PopUnion }
-export { PopUnion as PopUnion_alias_1 }
-export { PopUnion as PopUnion_alias_2 }
-
-declare const provideFactoryContext: Injectors['provideFactoryContext'];
-export { provideFactoryContext }
-export { provideFactoryContext as provideFactoryContext_alias_1 }
-
-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;
-}
-export { Registry }
-export { Registry as Registry_alias_1 }
-
-/**
- * Request context holder that manages pre-prepared instances for a specific request.
- * This allows for efficient instantiation of request-scoped services.
- */
-declare interface RequestContextHolder {
-    /**
-     * Unique identifier for this request context.
-     */
-    readonly requestId: string;
-    /**
-     * Instance holders for request-scoped services.
-     */
-    readonly holders: Map<string, ServiceLocatorInstanceHolder>;
-    /**
-     * 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: ServiceLocatorInstanceHolder): 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): ServiceLocatorInstanceHolder | undefined;
-    /**
-     * 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: ServiceLocatorInstanceHolder<any>, key: string) => boolean): Map<string, ServiceLocatorInstanceHolder>;
-    /**
-     * 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;
-}
-export { RequestContextHolder }
-export { RequestContextHolder as RequestContextHolder_alias_1 }
-
-/**
- * RequestContextManager handles request context lifecycle management.
- * Extracted from ServiceLocator to improve separation of concerns.
- */
-export declare class RequestContextManager {
-    private readonly logger;
-    private readonly requestContexts;
-    private currentRequestContext;
-    constructor(logger?: Console | null);
-    /**
-     * Begins a new request context with the given parameters.
-     * @param requestId Unique identifier for this request
-     * @param metadata Optional metadata for the request
-     * @param priority Priority for resolution (higher = more priority)
-     * @returns The created request context holder
-     */
-    beginRequest(requestId: string, metadata?: Record<string, any>, priority?: number): RequestContextHolder;
-    /**
-     * Ends a request context and cleans up all associated instances.
-     * @param requestId The request ID to end
-     */
-    endRequest(requestId: string): Promise<void>;
-    /**
-     * Gets the current request context.
-     * @returns The current request context holder or null
-     */
-    getCurrentRequestContext(): RequestContextHolder | null;
-    /**
-     * Sets the current request context.
-     * @param requestId The request ID to set as current
-     */
-    setCurrentRequestContext(requestId: string): void;
-    /**
-     * Gets all request contexts.
-     * @returns Map of request contexts
-     */
-    getRequestContexts(): Map<string, RequestContextHolder>;
-    /**
-     * Clears all request contexts.
-     */
-    clearAllRequestContexts(): Promise<void>;
-}
-
-/**
- * ServiceInstantiator handles the instantiation of services based on registry records.
- * It replaces the hard-coded logic in Injectable and Factory decorators.
- */
-declare class ServiceInstantiator {
-    private readonly injectors;
-    constructor(injectors: Injectors);
-    /**
-     * Instantiates a service based on its registry record.
-     * @param ctx The factory context for dependency injection
-     * @param record The factory record from the registry
-     * @param args Optional arguments for the service
-     * @returns Promise resolving to [undefined, instance] or [error]
-     */
-    instantiateService<T>(ctx: FactoryContext, record: FactoryRecord<T, any>, args?: any): Promise<[undefined, T] | [Error]>;
-    /**
-     * Instantiates a class-based service (Injectable decorator).
-     * @param ctx The factory context for dependency injection
-     * @param record The factory record from the registry
-     * @param args Optional arguments for the service constructor
-     * @returns Promise resolving to [undefined, instance] or [error]
-     */
-    private instantiateClass;
-    /**
-     * Instantiates a factory-based service (Factory decorator).
-     * @param ctx The factory context for dependency injection
-     * @param record The factory record from the registry
-     * @param args Optional arguments for the factory
-     * @returns Promise resolving to [undefined, instance] or [error]
-     */
-    private instantiateFactory;
-}
-export { ServiceInstantiator }
-export { ServiceInstantiator as ServiceInstantiator_alias_1 }
-
-/**
- * ServiceInvalidator handles service invalidation, cleanup, and graceful clearing.
- * Extracted from ServiceLocator to improve separation of concerns.
- */
-export declare class ServiceInvalidator {
-    private readonly manager;
-    private readonly requestContextManager;
-    private readonly eventBus;
-    private readonly logger;
-    constructor(manager: ServiceLocatorManager, requestContextManager: RequestContextManager, eventBus: ServiceLocatorEventBus, logger?: Console | null);
-    /**
-     * Invalidates a service and all its dependencies.
-     */
-    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.
-     */
-    clearAll(options?: ClearAllOptions): Promise<void>;
-    /**
-     * Waits for all services to settle (either created, destroyed, or error state).
-     */
-    ready(): Promise<void>;
-    /**
-     * Invalidates a single holder based on its current status.
-     */
-    private invalidateHolder;
-    /**
-     * Invalidates a request-scoped holder based on its current status.
-     */
-    private invalidateRequestHolder;
-    /**
-     * Common invalidation logic for holders based on their status.
-     */
-    private invalidateHolderByStatus;
-    /**
-     * Destroys a holder and cleans up its resources.
-     */
-    private destroyHolder;
-    /**
-     * Destroys a request-scoped holder and cleans up its resources.
-     */
-    private destroyRequestHolder;
-    /**
-     * Common destroy logic for holders with customizable cleanup.
-     */
-    private destroyHolderWithCleanup;
-    /**
-     * Waits for a holder to settle (either created, destroyed, or error state).
-     */
-    private waitForHolderToSettle;
-    /**
-     * Clears services with dependency awareness, ensuring proper cleanup order.
-     * Services with no dependencies are cleared first, then services that depend on them.
-     */
-    private clearServicesWithDependencyAwareness;
-    /**
-     * 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 findServicesReadyForClearing;
-    /**
-     * Force clears services that couldn't be cleared through normal dependency resolution.
-     * This handles edge cases like circular dependencies.
-     */
-    private forceClearServices;
-    /**
-     * Gets all service names currently managed by the ServiceLocator.
-     */
-    private getAllServiceNames;
-    /**
-     * Emits events to listeners for instance lifecycle events.
-     */
-    private emitInstanceEvent;
-}
-
-declare class ServiceLocator {
-    private readonly registry;
-    private readonly logger;
-    private readonly injectors;
-    private readonly eventBus;
-    private readonly manager;
-    private readonly serviceInstantiator;
-    private readonly tokenProcessor;
-    private readonly requestContextManager;
-    private readonly serviceInvalidator;
-    private readonly instanceResolver;
-    constructor(registry?: Registry, logger?: Console | null, injectors?: Injectors);
-    getEventBus(): ServiceLocatorEventBus;
-    getManager(): ServiceLocatorManager;
-    getRequestContexts(): Map<string, RequestContextHolder>;
-    getRequestContextManager(): RequestContextManager;
-    getServiceInvalidator(): ServiceInvalidator;
-    getInstanceIdentifier(token: AnyInjectableType, args?: any): string;
-    getInstance(token: AnyInjectableType, args?: any, onPrepare?: (data: {
-        instanceName: string;
-        actualToken: any;
-        validatedArgs?: any;
-    }) => void): Promise<any[]>;
-    getOrThrowInstance<Instance>(token: AnyInjectableType, args: any): Promise<Instance>;
-    getSyncInstance<Instance, Schema extends InjectionTokenSchemaType | undefined>(token: AnyInjectableType, args: Schema extends ZodObject ? z.input<Schema> : Schema extends ZodOptional<ZodObject> ? z.input<Schema> | undefined : undefined): 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>;
-    /**
-     * Begins a new request context with the given parameters.
-     * @param requestId Unique identifier for this request
-     * @param metadata Optional metadata for the request
-     * @param priority Priority for resolution (higher = more priority)
-     * @returns The created request context holder
-     */
-    beginRequest(requestId: string, metadata?: Record<string, any>, priority?: number): RequestContextHolder;
-    /**
-     * Ends a request context and cleans up all associated instances.
-     * @param requestId The request ID to end
-     */
-    endRequest(requestId: string): Promise<void>;
-    /**
-     * Gets the current request context.
-     * @returns The current request context holder or null
-     */
-    getCurrentRequestContext(): RequestContextHolder | null;
-    /**
-     * Sets the current request context.
-     * @param requestId The request ID to set as current
-     */
-    setCurrentRequestContext(requestId: string): void;
-    /**
-     * Waits for all services to settle (either created, destroyed, or error state).
-     */
-    ready(): Promise<void>;
-    /**
-     * Helper method for TokenProcessor to access pre-prepared instances.
-     * This is needed for the factory context creation.
-     */
-    tryGetPrePreparedInstance(instanceName: string, contextHolder: RequestContextHolder | undefined, deps: Set<string>): any;
-    /**
-     * Helper method for InstanceResolver to generate instance names.
-     * This is needed for the factory context creation.
-     */
-    generateInstanceName(token: any, args: any): string;
-}
-export { ServiceLocator }
-export { ServiceLocator as ServiceLocator_alias_1 }
-
-declare class ServiceLocatorEventBus {
-    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>;
-}
-export { ServiceLocatorEventBus }
-export { ServiceLocatorEventBus as ServiceLocatorEventBus_alias_1 }
-
-declare type ServiceLocatorInstanceDestroyListener = () => void | Promise<void>;
-export { ServiceLocatorInstanceDestroyListener }
-export { ServiceLocatorInstanceDestroyListener as ServiceLocatorInstanceDestroyListener_alias_1 }
-
-declare type ServiceLocatorInstanceEffect = () => void;
-export { ServiceLocatorInstanceEffect }
-export { ServiceLocatorInstanceEffect as ServiceLocatorInstanceEffect_alias_1 }
-
-declare type ServiceLocatorInstanceHolder<Instance = unknown> = ServiceLocatorInstanceHolderCreating<Instance> | ServiceLocatorInstanceHolderCreated<Instance> | ServiceLocatorInstanceHolderDestroying<Instance> | ServiceLocatorInstanceHolderError;
-export { ServiceLocatorInstanceHolder }
-export { ServiceLocatorInstanceHolder as ServiceLocatorInstanceHolder_alias_1 }
-
-declare interface ServiceLocatorInstanceHolderCreated<Instance> {
-    status: ServiceLocatorInstanceHolderStatus.Created;
-    name: string;
-    instance: Instance;
-    creationPromise: null;
-    destroyPromise: null;
-    type: InjectableType;
-    scope: InjectableScope;
-    deps: Set<string>;
-    destroyListeners: ServiceLocatorInstanceDestroyListener[];
-    createdAt: number;
-}
-export { ServiceLocatorInstanceHolderCreated }
-export { ServiceLocatorInstanceHolderCreated as ServiceLocatorInstanceHolderCreated_alias_1 }
-
-declare interface ServiceLocatorInstanceHolderCreating<Instance> {
-    status: ServiceLocatorInstanceHolderStatus.Creating;
-    name: string;
-    instance: null;
-    creationPromise: Promise<[undefined, Instance]> | null;
-    destroyPromise: null;
-    type: InjectableType;
-    scope: InjectableScope;
-    deps: Set<string>;
-    destroyListeners: ServiceLocatorInstanceDestroyListener[];
-    createdAt: number;
-}
-export { ServiceLocatorInstanceHolderCreating }
-export { ServiceLocatorInstanceHolderCreating as ServiceLocatorInstanceHolderCreating_alias_1 }
-
-declare interface ServiceLocatorInstanceHolderDestroying<Instance> {
-    status: ServiceLocatorInstanceHolderStatus.Destroying;
-    name: string;
-    instance: Instance | null;
-    creationPromise: null;
-    destroyPromise: Promise<void>;
-    type: InjectableType;
-    scope: InjectableScope;
-    deps: Set<string>;
-    destroyListeners: ServiceLocatorInstanceDestroyListener[];
-    createdAt: number;
-}
-export { ServiceLocatorInstanceHolderDestroying }
-export { ServiceLocatorInstanceHolderDestroying as ServiceLocatorInstanceHolderDestroying_alias_1 }
-
-declare interface ServiceLocatorInstanceHolderError {
-    status: ServiceLocatorInstanceHolderStatus.Error;
-    name: string;
-    instance: Error;
-    creationPromise: null;
-    destroyPromise: null;
-    type: InjectableType;
-    scope: InjectableScope;
-    deps: Set<string>;
-    destroyListeners: ServiceLocatorInstanceDestroyListener[];
-    createdAt: number;
-}
-export { ServiceLocatorInstanceHolderError }
-export { ServiceLocatorInstanceHolderError as ServiceLocatorInstanceHolderError_alias_1 }
-
-declare enum ServiceLocatorInstanceHolderStatus {
-    Created = "created",
-    Creating = "creating",
-    Destroying = "destroying",
-    Error = "error"
-}
-export { ServiceLocatorInstanceHolderStatus }
-export { ServiceLocatorInstanceHolderStatus as ServiceLocatorInstanceHolderStatus_alias_1 }
-
-declare class ServiceLocatorManager extends BaseInstanceHolderManager {
-    constructor(logger?: Console | null);
-    get(name: string): [DIError, ServiceLocatorInstanceHolder] | [DIError] | [undefined, ServiceLocatorInstanceHolder];
-    set(name: string, holder: ServiceLocatorInstanceHolder): void;
-    has(name: string): [DIError] | [undefined, boolean];
-    /**
-     * 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
-     */
-    storeCreatedHolder<Instance>(name: string, instance: Instance, type: InjectableType, scope: InjectableScope, deps?: Set<string>): ServiceLocatorInstanceHolder<Instance>;
-}
-export { ServiceLocatorManager }
-export { ServiceLocatorManager as ServiceLocatorManager_alias_1 }
-
-export declare const test1: string;
-
-export declare const test2: number;
-
-export declare const test3: boolean;
-
-export declare const test4: {
-    name: string;
-};
-
-export declare const test5: object;
-
-/**
- * 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;
-}
-export { TestBindingBuilder }
-export { TestBindingBuilder as TestBindingBuilder_alias_1 }
-
-/**
- * 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;
-}
-export { TestContainer }
-export { TestContainer as TestContainer_alias_1 }
-
-/**
- * TokenProcessor handles token validation, resolution, and instance name generation.
- * Extracted from ServiceLocator to improve separation of concerns.
- */
-export declare class TokenProcessor {
-    private readonly logger;
-    constructor(logger?: Console | null);
-    /**
-     * 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 serviceLocator Reference to the service locator for dependency resolution
-     */
-    createFactoryContext(serviceLocator: ServiceLocator): FactoryContext & {
-        getDestroyListeners: () => (() => void)[];
-        deps: Set<string>;
-    };
-    /**
-     * Tries to get a pre-prepared instance from request contexts.
-     */
-    tryGetPrePreparedInstance(instanceName: string, contextHolder: RequestContextHolder | undefined, deps: Set<string>, currentRequestContext: RequestContextHolder | null): any;
-}
-
-declare type UnionToArray<T, A extends unknown[] = []> = IsUnion<T> extends true ? UnionToArray<Exclude<T, PopUnion<T>>, [PopUnion<T>, ...A]> : [T, ...A];
-export { UnionToArray }
-export { UnionToArray as UnionToArray_alias_1 }
-export { UnionToArray as UnionToArray_alias_2 }
-
-declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-export { UnionToIntersection }
-export { UnionToIntersection as UnionToIntersection_alias_1 }
-export { UnionToIntersection as UnionToIntersection_alias_2 }
-
-declare type UnionToOvlds<U> = UnionToIntersection<U extends any ? (f: U) => void : never>;
-export { UnionToOvlds }
-export { UnionToOvlds as UnionToOvlds_alias_1 }
-export { UnionToOvlds as UnionToOvlds_alias_2 }
-
-declare const wrapSyncInit: Injectors['wrapSyncInit'];
-export { wrapSyncInit }
-export { wrapSyncInit as wrapSyncInit_alias_1 }
-
-export { }