/**
 * Circuit Breaker pattern implementation for external API calls
 * Protects against cascading failures and provides fallback mechanisms
 */
export declare enum CircuitState {
    CLOSED = "CLOSED",// Normal operation
    OPEN = "OPEN",// Circuit is open, calls fail fast
    HALF_OPEN = "HALF_OPEN"
}
export interface CircuitBreakerOptions {
    failureThreshold: number;
    recoveryTimeout: number;
    requestTimeout: number;
    monitoringWindow: number;
}
export interface CircuitBreakerStats {
    state: CircuitState;
    failures: number;
    successes: number;
    lastFailureTime?: number;
    totalRequests: number;
}
export interface ErrorDetails {
    message: string;
    state: CircuitState;
    failures: number;
    lastFailureTime?: number;
    successRate: number;
    timeSinceLastFailure?: number;
    stats: CircuitBreakerStats;
}
export declare class CircuitBreakerError extends Error {
    readonly details: ErrorDetails;
    readonly options: CircuitBreakerOptions;
    constructor(message: string, details: any, options: CircuitBreakerOptions);
    toString(): string;
}
export declare class CircuitBreaker {
    private options;
    private state;
    private failures;
    private successes;
    private lastFailureTime?;
    private totalRequests;
    private requestTimeouts;
    constructor(options: CircuitBreakerOptions);
    execute<T>(operation: () => Promise<T>, fallback?: () => Promise<T>): Promise<T>;
    private executeWithTimeout;
    private onSuccess;
    private onFailure;
    private canAttemptReset;
    private cleanOldFailures;
    getStats(): CircuitBreakerStats;
    reset(): void;
    private getDetailedErrorInfo;
}
export declare const createOpenAICircuitBreaker: () => CircuitBreaker;
export declare const createRustAnalyzerCircuitBreaker: () => CircuitBreaker;
//# sourceMappingURL=circuit-breaker.d.ts.map