import { Constructor, Token } from './tokens.js';
import { OnDestroy, OnInit } from './lifecycle.js';
export declare enum Scope {
    SINGLETON = "singleton",
    REQUEST = "request",
    TRANSIENT = "transient",
    SESSION = "session"
}
export interface ParamFlags {
    optional?: boolean;
    self?: boolean;
    skipSelf?: boolean;
    lazy?: boolean;
    multiple?: boolean;
}
export interface ResolveOptions {
    request?: ResolutionContext;
    flags?: ParamFlags;
    scope?: Scope;
}
export declare class ResolutionContext {
    readonly requestId: `${string}-${string}-${string}-${string}-${string}`;
    requestCache: Map<any, any>;
    depth: number;
    maxDepth: number;
    circularCheck: Set<any>;
    constructor(requestId?: `${string}-${string}-${string}-${string}-${string}`);
    enter(token: any): boolean;
    exit(token: any): void;
    clear(): void;
}
export interface ProviderRecord {
    provider: AnyProvider;
    scope?: Scope | undefined;
    priority?: number | undefined;
    condition?: ((container: any) => boolean) | undefined;
}
export interface ValueProvider<T = any> {
    provide: Token<T>;
    useValue: T;
    scope?: Scope;
    priority?: number;
    condition?: (container: any) => boolean;
}
export interface ClassProvider<T = any> {
    provide: Token<T>;
    useClass: Constructor<T>;
    scope?: Scope;
    priority?: number | undefined;
    condition?: ((container: any) => boolean) | undefined;
}
export interface FactoryProvider<T = any> {
    provide: Token<T>;
    useFactory: (container: any, ...args: any[]) => T | Promise<T>;
    inject?: Token[];
    scope?: Scope;
    priority?: number;
    condition?: (container: any) => boolean;
}
export interface ExistingProvider<T = any> {
    provide: Token<T>;
    useExisting: Token<T>;
    scope?: Scope;
    priority?: number;
    condition?: (container: any) => boolean;
}
export type AnyProvider = ValueProvider | ClassProvider | FactoryProvider | ExistingProvider;
export interface ContainerOptions {
    parent?: any;
    autoRegisterInjectable?: boolean;
    strictMode?: boolean;
    enableCircularDetection?: boolean;
    maxResolutionDepth?: number;
}
export interface RegistrationOptions {
    scope?: Scope;
    priority?: number;
    condition?: (container: any) => boolean;
    override?: boolean;
}
export interface Resolver<T = any> {
    resolve(container: any, context: ResolutionContext): T | Promise<T>;
    canResolve(token: Token<T>): boolean;
}
export interface LifecycleManager {
    onInit(instance: OnInit): void;
    onDestroy(instance: OnDestroy): void;
    destroyAll(): Promise<void>;
}
export interface Container extends LifecycleManager {
    register(providers: AnyProvider | AnyProvider[], options?: RegistrationOptions): void;
    registerSingleton<T>(token: Token<T>, factory: () => T | Promise<T>): void;
    registerTransient<T>(token: Token<T>, factory: () => T | Promise<T>): void;
    registerRequest<T>(token: Token<T>, factory: () => T | Promise<T>): void;
    get<T>(token: Token<T>, options?: ResolveOptions): Promise<T>;
    getAll<T>(token: Token<T>, options?: ResolveOptions): Promise<T[]>;
    has(token: Token): boolean;
    createChild(options?: ContainerOptions): any;
    dispose(): Promise<void>;
}
export interface ModuleMetadata {
    imports?: any[];
    providers?: AnyProvider[];
    exports?: Token[];
    controllers?: Constructor[];
}
export interface InjectableMetadata {
    scope?: Scope;
    priority?: number;
    condition?: (container: any) => boolean;
    autoRegister?: boolean;
    interfaces?: Token[];
}
export interface InjectionMetadata {
    token?: any;
    optional?: boolean;
    self?: boolean;
    skipSelf?: boolean;
    lazy?: boolean;
    multiple?: boolean;
    transform?: (value: any) => any;
}
export type DependencyGraph = Map<Token, Set<Token>>;
export interface ContainerStats {
    totalProviders: number;
    singletons: number;
    requestScoped: number;
    transient: number;
    circularDependencies: number;
    resolutionTime: number;
}
export interface ValidationResult {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    circularDependencies: Token[][];
    missingDependencies: {
        token: Token;
        missing: Token[];
    }[];
}
//# sourceMappingURL=types.d.ts.map