/**
 * Error thrown when a DI container operation fails.
 *
 * Used for container creation, service resolution, and validation errors.
 */
export declare class DIContainerError extends Error {
    /**
     * Create a new DI container error.
     *
     * @param containerName - Name or identifier of the container
     * @param message - Detailed error message
     */
    constructor(containerName: string, message: string);
}
/**
 * Error thrown when Ties class registration fails.
 *
 * Used when a Ties class doesn't implement the required register() method
 * or when registration fails for other reasons.
 */
export declare class TiesRegistrationError extends Error {
    /**
     * Create a new Ties registration error.
     *
     * @param tiesClassName - Name of the Ties class that failed
     * @param reason - Reason for the registration failure
     */
    constructor(tiesClassName: string, reason: string);
}
/**
 * Error thrown when a required service is not found in the container.
 *
 * Used when attempting to resolve a service that hasn't been registered.
 */
export declare class MissingServiceError extends Error {
    /**
     * Create a new missing service error.
     *
     * @param serviceName - Name of the missing service
     * @param containerName - Name or identifier of the container
     */
    constructor(serviceName: string, containerName: string);
}
/**
 * Comprehensive error types for container lifecycle failures.
 */
/**
 * Error thrown when hash computation fails.
 */
export declare class HashComputationError extends Error {
    readonly className: string;
    readonly classCode: string;
    readonly originalError: Error;
    constructor(className: string, classCode: string, originalError: Error);
}
/**
 * Error thrown when hash collision is detected.
 */
export declare class HashCollisionError extends Error {
    readonly hashKey: string;
    readonly conflictingClasses: string[];
    constructor(hashKey: string, conflictingClasses: string[]);
}
/**
 * Error thrown when bundle import fails.
 */
export declare class BundleImportError extends Error {
    readonly bundlePath: string;
    readonly expectedStructure: string[];
    readonly actualStructure: string[];
    readonly originalError?: Error | undefined;
    constructor(bundlePath: string, expectedStructure: string[], actualStructure: string[], originalError?: Error | undefined);
}
/**
 * Error thrown when dependency resolution fails.
 */
export declare class DependencyResolutionError extends Error {
    readonly serviceName: string;
    readonly hashKey: string;
    readonly availableServices: string[];
    readonly context: string;
    constructor(serviceName: string, hashKey: string, availableServices: string[], context: string);
}
/**
 * Error thrown when container validation fails.
 */
export declare class ContainerValidationError extends Error {
    readonly validationErrors: string[];
    readonly containerState: ContainerDiagnostics;
    constructor(validationErrors: string[], containerState: ContainerDiagnostics);
}
/**
 * Error thrown when metadata loading fails.
 */
export declare class MetadataLoadingError extends Error {
    readonly metadataPath: string;
    readonly expectedFormat: string;
    readonly originalError?: Error | undefined;
    constructor(metadataPath: string, expectedFormat: string, originalError?: Error | undefined);
}
/**
 * Error thrown when circular dependencies are detected.
 */
export declare class CircularDependencyError extends Error {
    readonly circularChains: Array<{
        chain: string[];
        hashKeys: string[];
    }>;
    constructor(circularChains: Array<{
        chain: string[];
        hashKeys: string[];
    }>);
}
/**
 * Diagnostic information for container state.
 */
export interface ContainerDiagnostics {
    /** Container initialization phase */
    phase: string;
    /** Number of services registered */
    serviceCount: number;
    /** Number of Lambda handlers */
    lambdaCount: number;
    /** Container initialization time in milliseconds */
    initializationTime: number;
    /** Available service names */
    availableServices: string[];
    /** Available Lambda handler IDs */
    availableLambdas: string[];
    /** Container initialization errors */
    errors: Array<{
        phase: string;
        serviceName?: string;
        hashKey?: string;
        error: string;
        timestamp: number;
    }>;
    /** Container warnings */
    warnings: string[];
    /** Performance metrics */
    performanceMetrics: {
        coldStartTime?: number;
        dependencyResolutionTime?: number;
        validationTime?: number;
    };
}
/**
 * Error recovery and fallback mechanisms.
 */
export interface ErrorRecoveryOptions {
    /** Whether to attempt fallback to class name resolution */
    fallbackToClassName: boolean;
    /** Whether to continue with partial container initialization */
    allowPartialInitialization: boolean;
    /** Maximum number of retry attempts */
    maxRetries: number;
    /** Retry delay in milliseconds */
    retryDelay: number;
    /** Services that can be skipped if registration fails */
    optionalServices: string[];
}
/**
 * Default error recovery options.
 */
export declare const DEFAULT_ERROR_RECOVERY_OPTIONS: ErrorRecoveryOptions;
