/**
 * Error Handling and Retry Mechanisms for NoSQL Storage Engine
 * Designed for resilience and fault tolerance with sub-10ms recovery targets
 */
import { StorageError, StorageResult } from '../types';
export interface RetryConfig {
    maxRetries: number;
    baseDelayMs: number;
    maxDelayMs: number;
    backoffMultiplier: number;
    jitterMs: number;
    retryableErrors: string[];
    circuitBreakerThreshold: number;
    circuitBreakerTimeoutMs: number;
}
export interface ErrorContext {
    operation: string;
    backend: string;
    shard?: string;
    attempt: number;
    totalAttempts: number;
    timestamp: number;
    metadata?: Record<string, any>;
}
export interface CircuitBreakerState {
    state: 'closed' | 'open' | 'half-open';
    failureCount: number;
    lastFailureTime: number;
    nextAttemptTime: number;
    successCount: number;
}
export type ErrorHandler = (error: StorageError, context: ErrorContext) => Promise<boolean>;
export declare class RetryableOperation<T> {
    private config;
    private circuitBreakers;
    private errorHandlers;
    private errorHistory;
    constructor(config: RetryConfig);
    execute<T>(operation: () => Promise<StorageResult<T>>, context?: Partial<ErrorContext>): Promise<StorageResult<T>>;
    addErrorHandler(handler: ErrorHandler): void;
    removeErrorHandler(handler: ErrorHandler): void;
    getErrorHistory(): Array<{
        error: StorageError;
        context: ErrorContext;
    }>;
    getCircuitBreakerState(backend: string, shard?: string): CircuitBreakerState | null;
    resetCircuitBreaker(backend: string, shard?: string): void;
    private shouldRetry;
    private delay;
    private wrapError;
    private isRetryableError;
    private recordError;
    private isCircuitOpen;
    private recordSuccess;
    private recordFailure;
}
export declare class DatabaseErrorHandler {
    static createRetryConfig(): RetryConfig;
    static createD1ErrorHandler(): ErrorHandler;
    static createKVErrorHandler(): ErrorHandler;
    static createR2ErrorHandler(): ErrorHandler;
    static createDurableObjectErrorHandler(): ErrorHandler;
}
export declare class OperationBulkhead {
    private defaultMaxConcurrent;
    private resourcePools;
    constructor(defaultMaxConcurrent?: number);
    execute<T>(resourceKey: string, operation: () => Promise<T>, maxConcurrent?: number): Promise<T>;
    getResourceUsage(resourceKey: string): {
        active: number;
        queued: number;
        maxConcurrent: number;
    } | null;
    getAllResourceUsage(): Record<string, {
        active: number;
        queued: number;
        maxConcurrent: number;
    }>;
    private getOrCreatePool;
    private processQueue;
}
export declare class HealthChecker {
    private healthChecks;
    private intervals;
    private listeners;
    addHealthCheck(name: string, check: () => Promise<boolean>, interval?: number, timeout?: number): void;
    removeHealthCheck(name: string): void;
    onHealthChange(name: string, listener: (healthy: boolean) => void): void;
    getHealthStatus(name: string): {
        healthy: boolean;
        lastCheck: number;
        consecutiveFailures: number;
    } | null;
    getAllHealthStatuses(): Record<string, {
        healthy: boolean;
        lastCheck: number;
        consecutiveFailures: number;
    }>;
    destroy(): void;
    private performHealthCheck;
}
export declare class ErrorRecoveryManager {
    private recoveryStrategies;
    addRecoveryStrategy(errorCode: string, strategy: (error: StorageError, context: ErrorContext) => Promise<void>): void;
    attemptRecovery(error: StorageError, context: ErrorContext): Promise<boolean>;
    static createDefaultStrategies(): ErrorRecoveryManager;
}
//# sourceMappingURL=error-handling.d.ts.map