/**
 * Circuit Breaker implementation for robust error handling
 *
 * States:
 * - CLOSED: Normal operation, requests pass through
 * - OPEN: Circuit is open, requests fail fast
 * - HALF_OPEN: Testing if service has recovered
 */
export declare enum CircuitState {
    CLOSED = "CLOSED",
    OPEN = "OPEN",
    HALF_OPEN = "HALF_OPEN"
}
export interface CircuitBreakerConfig {
    /** Number of failures before opening circuit */
    failureThreshold: number;
    /** Time in ms to wait before trying HALF_OPEN */
    recoveryTimeout: number;
    /** Number of successful calls needed to close circuit */
    successThreshold: number;
    /** Time window for counting failures (ms) */
    failureWindow: number;
}
export interface CircuitBreakerStats {
    state: CircuitState;
    failures: number;
    successes: number;
    lastFailureTime: number | null;
    nextAttemptTime: number | null;
}
export declare class CircuitBreaker {
    private config;
    private state;
    private failures;
    private successes;
    private lastFailureTime;
    private nextAttemptTime;
    private failureTimes;
    constructor(config: CircuitBreakerConfig);
    /**
     * Execute a function with circuit breaker protection
     */
    execute<T>(fn: () => Promise<T>): Promise<T>;
    /**
     * Check if circuit breaker allows requests
     */
    canExecute(): boolean;
    /**
     * Get current circuit breaker statistics
     */
    getStats(): CircuitBreakerStats;
    /**
     * Reset circuit breaker to initial state
     */
    reset(): void;
    private onSuccess;
    private onFailure;
}
/**
 * Exponential backoff with jitter for retry operations
 */
export interface RetryConfig {
    /** Maximum number of retry attempts */
    maxRetries: number;
    /** Base delay in milliseconds */
    baseDelay: number;
    /** Maximum delay in milliseconds */
    maxDelay: number;
    /** Multiplier for exponential backoff */
    multiplier: number;
    /** Jitter factor (0-1) to add randomness */
    jitter: number;
}
export declare class ExponentialBackoff {
    private config;
    constructor(config: RetryConfig);
    /**
     * Calculate delay for given attempt number
     */
    getDelay(attempt: number): number;
    /**
     * Execute function with exponential backoff retry
     */
    execute<T>(fn: () => Promise<T>, circuitBreaker?: CircuitBreaker): Promise<T>;
    private sleep;
}
/**
 * Default configurations for common use cases
 */
export declare const DEFAULT_CIRCUIT_BREAKER_CONFIG: CircuitBreakerConfig;
export declare const DEFAULT_RETRY_CONFIG: RetryConfig;