import type { FactoryProvider } from './types/factory-provider.js';
import type { InjectableClass } from './types/injectable-class.js';
import type { Token } from './types/tokens.js';
import { ScopeBuilder } from './scope-builder.js';
import { ScopedContainer } from './scoped-container.js';
/**
 * Data for a scoped class registration.
 */
export interface ScopedClassData<T = unknown> {
    Class: InjectableClass<T, readonly Token<any>[]>;
    deps: readonly Token<unknown>[];
}
/**
 * Data required to construct a Container.
 * This is the "state" that ContainerBuilder prepares.
 */
export interface ContainerState {
    instances: Map<Token<unknown>, unknown>;
    factoryProviders: Map<Token<unknown>, FactoryProvider<any, any, any>>;
    valueProviders: Set<Token<unknown>>;
    initOrder: Token<unknown>[];
    scopedClassProviders: Map<Token<unknown>, ScopedClassData>;
    scopedFactoryProviders: Map<Token<unknown>, FactoryProvider<any, any, any>>;
    scopedValueTokens: Set<Token<unknown>>;
}
export declare class Container {
    private readonly instances;
    private readonly factoryProviders;
    private readonly valueProviders;
    private readonly initOrder;
    private readonly scopedClassProviders;
    private readonly scopedFactoryProviders;
    private readonly scopedValueTokens;
    private isInitialized;
    constructor(state: ContainerState);
    /**
     * Get an instance by its token.
     */
    get<T>(token: Token<T>): T;
    /**
     * Create a new scoped container for scoped instances.
     * Scoped instances are created on-demand within the container and destroyed when the scoped container is destroyed.
     */
    createScope(): ScopedContainer;
    /**
     * Create a ScopeBuilder for constructing a scoped container with provided values.
     * Use this when you have scoped value tokens that need to be supplied per-scope.
     */
    createScopeBuilder(): ScopeBuilder;
    /**
     * Initialize all instances - calls onInit() in topological order (dependencies before dependents).
     * Only class-registered instances have onInit called (not values or factories).
     */
    init(): Promise<void>;
    /**
     * Destroy all instances - calls onDestroy() in reverse topological order (dependents before dependencies).
     */
    destroy(): Promise<void>;
}
//# sourceMappingURL=container.d.ts.map