import { Container } from './container.js';
import type { FactoryProvider } from './types/factory-provider.js';
import type { InjectableClass } from './types/injectable-class.js';
import type { RegistrationOptions } from './types/options.js';
import type { Token } from './types/tokens.js';
type ValidateArity<C extends new (...args: any[]) => any, Deps extends readonly Token<any>[]> = Deps['length'] extends ConstructorParameters<C>['length'] ? ConstructorParameters<C>['length'] extends Deps['length'] ? unknown : never : never;
/**
 * ContainerBuilder is the class you use to configure a Container.
 *
 * The ContainerBuilder has 2 main responsibilities:
 *   1. Collect all provider registrations, which can be defined in any order.
 *     - Handled by register* methods.
 *   2. Instantiate instances and register them in a new Container.
 *     - Handled by `.build()`.
 *
 * The ContainerBuilder does a topological sort to ensure that instances are created and destroyed
 * in the correct order (e.g. all of a providers dependencies must be created before that
 * provider's instance can be created, and destruction needs to happen in the opposite order).
 */
export declare class ContainerBuilder {
    private readonly registrations;
    /**
     * Register a static value.
     */
    registerValue<T>(token: Token<T>, value: T): this;
    /**
     * Declare a scoped value token whose value will be provided at scope creation time.
     * Scoped providers can depend on this token; the actual value is supplied via
     * `container.createScopeBuilder().provideValue(token, value).build()`.
     */
    registerScopedValue<T>(token: Token<T>): this;
    /**
     * Register a class with static deps property.
     * Dependencies are resolved automatically during build().
     * Type safety between the deps array and constructor params is enforced at this method.
     */
    registerClass<T, Deps extends readonly Token<any>[] = readonly [], C extends InjectableClass<T, Deps> = InjectableClass<T, Deps>>(Class: C & InjectableClass<T, Deps> & ValidateArity<C, Deps>, options?: RegistrationOptions): this;
    /**
     * Register a factory provider, which can be async or sync and can inject other dependencies.
     */
    registerFactory<T, Deps extends readonly Token<any>[], DestroyDeps extends readonly Token<any>[]>(provider: FactoryProvider<T, Deps, DestroyDeps>, options?: RegistrationOptions): this;
    /**
     * Merge providers from another container.
     *
     * This is useful for creating standalone packages/libraries that export a ContainerBuilder.
     * You can use `merge` to bring these standalone packages together into a single Container.
     */
    merge(other: ContainerBuilder): this;
    /**
     * Check if a token has been registered.
     */
    has(token: Token<unknown>): boolean;
    /**
     * Override an existing provider with a value; intended for mocking during tests.
     * Only works for singleton providers. For scoped providers, use overrideFactory instead.
     */
    overrideValue<T>(token: Token<T>, value: T): this;
    /**
     * Override an existing provider with a class; intended for mocking during tests.
     * Preserves the original provider's scope.
     */
    overrideClass<T, Deps extends readonly Token<any>[] = readonly [], C extends InjectableClass<T, Deps> = InjectableClass<T, Deps>>(token: Token<T>, Class: C & InjectableClass<T, Deps> & ValidateArity<C, Deps>): this;
    /**
     * Override an existing provider with a factory; intended for mocking during tests.
     * Preserves the original provider's scope.
     */
    overrideFactory<T, Deps extends readonly Token<any>[], DestroyDeps extends readonly Token<any>[]>(provider: FactoryProvider<T, Deps, DestroyDeps>): this;
    private assertTokenRegistered;
    /**
     * Build the container - topologically sorts providers and instantiates singletons.
     * Scoped providers are validated but not instantiated - they're stored for later use in Scopes.
     * By default, also initializes the container (calls onInit on all services).
     */
    build(options?: {
        init?: boolean;
    }): Promise<Container>;
    /**
     * Topologically sort providers by their dependencies using Kahn's algorithm.
     *
     * This ensures that dependent providers are created and initialized BEFORE the providers that
     * depend on them, and that dependent providers are destroyed AFTER providers that depend on them.
     *
     * Also validates that singleton providers do not depend on scoped providers.
     */
    private topologicalSort;
    /**
     * Find a cycle path using DFS with coloring.
     * Returns the cycle as an array of tokens ending with the repeated token.
     */
    private findCyclePath;
    private addRegistration;
    private isScoped;
    private isSingleton;
    /**
     * Resolve dependencies from the instances map.
     */
    private resolveDeps;
}
export {};
//# sourceMappingURL=container-builder.d.ts.map