/**
 * Infrastructure DI Container Implementation
 *
 * This module provides the DI container implementation for the declarative infrastructure API.
 * It supports Singleton, Transient, and Scoped lifecycles with binding override capabilities.
 *
 * @module declarative-api/di-container/infrastructure-di-container
 */
import type { DIScope, BindingId, DIBinding, DIBindingOverride, DIResolutionResult, IInfrastructureDIContainer, InfrastructureDIContainerOptions } from '../../../lib/runtime-web/types/declarative-api';
/**
 * Error thrown when DI resolution fails.
 */
export declare class DIResolutionError extends Error {
    readonly bindingId: BindingId;
    readonly cause?: Error | undefined;
    readonly code: "DI_RESOLUTION_ERROR";
    constructor(bindingId: BindingId, cause?: Error | undefined);
}
/**
 * Type guard for DIResolutionError.
 */
export declare function isDIResolutionError(error: unknown): error is DIResolutionError;
/**
 * Error thrown when DI binding fails.
 */
export declare class DIBindingError extends Error {
    readonly bindingId: BindingId;
    readonly code: "DI_BINDING_ERROR";
    constructor(bindingId: BindingId, message: string);
}
/**
 * Type guard for DIBindingError.
 */
export declare function isDIBindingError(error: unknown): error is DIBindingError;
/**
 * Infrastructure DI Container implementation.
 *
 * Provides dependency injection with support for:
 * - Singleton scope: Same instance for all resolutions
 * - Transient scope: New instance for each resolution
 * - Scoped scope: Same instance within a scope (child container)
 * - Binding overrides: Replace default bindings with custom implementations
 *
 * @todo: complete with PureContainer logic
 *        Refactor PureContainer instnace options name
 *
 * Validates: Requirements 17.2, 17.3, 17.4, 17.5
 */
export declare class InfrastructureDIContainer implements IInfrastructureDIContainer {
    private readonly bindings;
    private readonly scopedInstances;
    private readonly defaultScope;
    private readonly parent?;
    private readonly scopeId;
    private disposed;
    constructor(options?: InfrastructureDIContainerOptions);
    /**
     * Register a binding in the container.
     */
    register<T>(binding: DIBinding<T>): void;
    /**
     * Register multiple bindings at once.
     */
    registerAll(bindings: DIBinding[]): void;
    /**
     * Override an existing binding.
     */
    override<T>(override: DIBindingOverride<T>): void;
    /**
     * Resolve a dependency by its binding ID.
     */
    resolve<T>(id: BindingId): T;
    /**
     * Try to resolve a dependency, returning null if not found.
     */
    tryResolve<T>(id: BindingId): T | null;
    /**
     * Resolve a dependency with detailed result.
     */
    resolveWithResult<T>(id: BindingId): DIResolutionResult<T>;
    /**
     * Check if a binding exists.
     */
    has(id: BindingId): boolean;
    /**
     * Get all registered binding IDs.
     */
    getBindingIds(): BindingId[];
    /**
     * Get the scope of a binding.
     */
    getScope(id: BindingId): DIScope | undefined;
    /**
     * Create a child scope.
     */
    createScope(scopeId?: string): IInfrastructureDIContainer;
    /**
     * Dispose of the container and all scoped instances.
     */
    dispose(): void;
    /**
     * Get all bindings for debugging/introspection.
     */
    getBindings(): Map<BindingId, DIBinding>;
    /**
     * Resolve a binding entry to an instance.
     */
    private resolveEntry;
    /**
     * Ensure the container is not disposed.
     */
    private ensureNotDisposed;
}
/**
 * Factory function to create an infrastructure DI container.
 *
 * @param options - Container options
 * @returns A new DI container instance
 */
export declare function createInfrastructureDIContainer(options?: InfrastructureDIContainerOptions): IInfrastructureDIContainer;
