@elsikora/cladi/dist/cjs/infrastructure/class/di/container.class.d.ts

Zero-dependency TypeScript DI toolkit with typed tokens and scoped lifecycles.

import type { IContainerSnapshot, IDependencyGraph, IDIScopeCreateOptions, IResolutionExplanation } from '../../../domain/interface/index';
import type { IDIContainer, Provider, Token } from '../../../domain/type/index';
import type { IInternalContainerOptions } from './interface/internal-container-options.interface';
/**
 * Advanced DI container with scoped and async resolution support.
 */
export declare class DIContainer implements IDIContainer {
    id: string;
    get isLocked(): boolean;
    private readonly ASYNC_RESOLUTION_DRAIN_TIMEOUT_MS?;
    private readonly CACHE_COORDINATOR;
    private readonly CAPTIVE_DEPENDENCY_POLICY;
    private readonly CHILD_SCOPES;
    private readonly DEPENDENCY_GRAPH_COORDINATOR;
    private readonly DISPOSAL_COORDINATOR;
    private readonly DISPOSAL_MANAGER;
    private disposePromise?;
    private readonly DISPOSER_COORDINATOR;
    private readonly DISPOSERS;
    private readonly DISPOSERS_BY_TOKEN;
    private readonly DUPLICATE_PROVIDER_POLICY;
    private isDisposed;
    private isDisposing;
    private isScopeLocked;
    private readonly LOGGER;
    private readonly LOOKUP_COORDINATOR;
    private readonly PARENT?;
    private readonly PENDING_PROVIDER_CLEANUPS;
    private readonly PROVIDERS;
    private readonly REGISTRATION_COORDINATOR;
    private readonly RESOLUTION_COORDINATOR;
    private readonly RESOLUTION_ENGINE;
    private readonly RESOLVE_INTERCEPTOR_DISPATCHER;
    private readonly RESOLVE_INTERCEPTORS;
    private readonly ROOT;
    private readonly ROOT_SCOPE_COUNTER;
    private readonly ROOT_SINGLETON_CACHE;
    private readonly SCOPED_CACHE;
    constructor(options?: IInternalContainerOptions);
    bootstrap(tokens?: ReadonlyArray<Token<unknown>>): Promise<void>;
    createScope(name?: string, options?: IDIScopeCreateOptions): DIContainer;
    dispose(): Promise<void>;
    explain<T>(token: Token<T>): IResolutionExplanation;
    exportGraph(): IDependencyGraph;
    getRegisteredTokens(): Array<Token<unknown>>;
    has(token: Token<unknown>): boolean;
    lock(): void;
    register(providerOrProviders: Array<Provider> | Provider): void;
    resolve<T>(token: Token<T>): T;
    resolveAll<T>(token: Token<T>): Array<T>;
    resolveAllAsync<T>(token: Token<T>): Promise<Array<T>>;
    resolveAsync<T>(token: Token<T>): Promise<T>;
    resolveOptional<T>(token: Token<T>): T | undefined;
    resolveOptionalAsync<T>(token: Token<T>): Promise<T | undefined>;
    snapshot(): IContainerSnapshot;
    unregister<T>(token: Token<T>): Promise<boolean>;
    validate(): void;
    private assertToken;
    private collectCacheKeys;
    private describeToken;
    private disposeInternal;
    private ensureActive;
    private ensureNotDisposing;
    private ensureNotLocked;
    private getProviderRegistrationCount;
    private getSingletonProviderTokens;
    private hasAsyncCleanupHooks;
    private hasTrackedDisposersForTokenRecursively;
    private isProviderCleanupPending;
    private isRegistrationCurrent;
    private logProviderCleanupFailure;
    private queueProviderCleanup;
    private waitForProviderCleanup;
}
//# sourceMappingURL=container.class.d.ts.map