/**
 * Circuit Breaker Pattern Implementation
 *
 * Prevents infinite retry loops by implementing a circuit breaker pattern with:
 * - Max retry attempts tracking
 * - Exponential backoff delays
 * - Circuit states (CLOSED, OPEN, HALF_OPEN)
 * - Automatic reset after cooldown period
 * - Comprehensive logging for debugging
 */
export declare enum CircuitState {
    CLOSED = "CLOSED",// Normal operation, requests pass through
    OPEN = "OPEN",// Too many failures, requests fail immediately
    HALF_OPEN = "HALF_OPEN"
}
export interface CircuitBreakerConfig {
    /** Maximum number of consecutive failures before opening circuit */
    maxAttempts: number;
    /** Time in ms before attempting to reset from OPEN to HALF_OPEN */
    resetTimeout: number;
    /** Use exponential backoff for retry delays */
    exponentialBackoff: boolean;
    /** Base delay in ms for backoff calculation */
    baseDelay: number;
    /** Maximum delay in ms for backoff */
    maxDelay: number;
    /** Optional logger for circuit breaker events */
    logger?: Console;
    /** Identifier for this circuit breaker instance */
    name?: string;
}
export interface CircuitBreakerStats {
    state: CircuitState;
    failureCount: number;
    successCount: number;
    totalAttempts: number;
    lastFailureTime: number | null;
    lastSuccessTime: number | null;
    openedAt: number | null;
}
export declare class CircuitBreaker {
    private state;
    private failureCount;
    private successCount;
    private totalAttempts;
    private lastFailureTime;
    private lastSuccessTime;
    private openedAt;
    private resetTimer;
    private config;
    constructor(config?: Partial<CircuitBreakerConfig>);
    /**
     * Check if circuit allows request to proceed
     */
    canAttempt(): boolean;
    /**
     * Record successful execution
     */
    recordSuccess(): void;
    /**
     * Record failed execution
     */
    recordFailure(error?: unknown): void;
    /**
     * Get current retry delay based on failure count and backoff strategy
     */
    getRetryDelay(): number;
    /**
     * Reset circuit breaker to initial state
     */
    reset(): void;
    /**
     * Get current circuit breaker statistics
     */
    getStats(): CircuitBreakerStats;
    /**
     * Check if circuit is currently open
     */
    isOpen(): boolean;
    /**
     * Check if circuit is currently closed
     */
    isClosed(): boolean;
    /**
     * Check if circuit is in half-open state
     */
    isHalfOpen(): boolean;
    /**
     * Execute a function with circuit breaker protection
     */
    execute<T>(fn: () => Promise<T>): Promise<T>;
    /**
     * Execute with automatic retry and backoff
     */
    executeWithRetry<T>(fn: () => Promise<T>): Promise<T>;
    private shouldAttemptReset;
    private transitionTo;
    private scheduleReset;
    private clearResetTimer;
    private log;
}
/**
 * Factory function to create a circuit breaker with preset configurations
 */
export declare function createCircuitBreaker(name: string, config?: Partial<CircuitBreakerConfig>): CircuitBreaker;
/**
 * Preset configurations for common use cases
 */
export declare const CircuitBreakerPresets: {
    /** Aggressive retry for critical operations */
    readonly AGGRESSIVE: {
        readonly maxAttempts: 3;
        readonly resetTimeout: 10000;
        readonly baseDelay: 500;
        readonly maxDelay: 5000;
        readonly exponentialBackoff: true;
    };
    /** Balanced retry for normal operations */
    readonly BALANCED: {
        readonly maxAttempts: 5;
        readonly resetTimeout: 30000;
        readonly baseDelay: 1000;
        readonly maxDelay: 30000;
        readonly exponentialBackoff: true;
    };
    /** Conservative retry for non-critical operations */
    readonly CONSERVATIVE: {
        readonly maxAttempts: 10;
        readonly resetTimeout: 60000;
        readonly baseDelay: 2000;
        readonly maxDelay: 60000;
        readonly exponentialBackoff: true;
    };
    /** Linear backoff without exponential increase */
    readonly LINEAR: {
        readonly maxAttempts: 5;
        readonly resetTimeout: 30000;
        readonly baseDelay: 2000;
        readonly maxDelay: 10000;
        readonly exponentialBackoff: false;
    };
};
//# sourceMappingURL=circuit-breaker.d.ts.map