/**
 * Circuit Breaker Pattern Implementation
 *
 * Prevents cascading failures by monitoring operation failures
 * and temporarily blocking requests when failure rate is too high
 */
export interface CircuitBreakerConfig {
    /** Failure threshold to open circuit (default: 5) */
    failureThreshold: number;
    /** Success threshold to close circuit (default: 2) */
    successThreshold: number;
    /** Timeout in milliseconds before attempting to recover (default: 60000) */
    timeout: number;
    /** Monitor window in milliseconds (default: 60000) */
    monitoringWindow: number;
    /** Expected failure types that should trigger circuit breaker */
    expectedErrors?: Array<string | RegExp>;
    /** Unexpected failure types that should not trigger circuit breaker */
    ignoredErrors?: Array<string | RegExp>;
}
export declare enum CircuitState {
    CLOSED = "closed",// Normal operation
    OPEN = "open",// Circuit is open, failing fast
    HALF_OPEN = "half-open"
}
interface CircuitBreakerMetrics {
    failures: number;
    successes: number;
    requests: number;
    lastFailureTime: number | null;
    lastSuccessTime: number | null;
}
export interface CircuitBreakerEvents {
    stateChange: (newState: CircuitState, oldState: CircuitState) => void;
    failure: (error: Error) => void;
    success: () => void;
    reject: (error: Error) => void;
}
/**
 * Circuit Breaker implementation with configurable failure detection
 */
export declare class CircuitBreaker {
    private state;
    private readonly config;
    private metrics;
    private nextAttempt;
    private readonly eventHandlers;
    constructor(config?: Partial<CircuitBreakerConfig>);
    /**
     * Register event handler
     */
    on<K extends keyof CircuitBreakerEvents>(event: K, handler: CircuitBreakerEvents[K]): void;
    /**
     * Execute operation with circuit breaker protection
     */
    execute<T>(operation: () => Promise<T>): Promise<T>;
    /**
     * Get current circuit state
     */
    getState(): CircuitState;
    /**
     * Get current metrics
     */
    getMetrics(): Readonly<CircuitBreakerMetrics>;
    /**
     * Reset circuit breaker to initial state
     */
    reset(): void;
    /**
     * Manually open circuit (for testing or forced maintenance)
     */
    open(): void;
    /**
     * Check if circuit is currently available for requests
     */
    isAvailable(): boolean;
    /**
     * Handle successful operation
     */
    private onSuccess;
    /**
     * Handle failed operation
     */
    private onFailure;
    /**
     * Check if circuit should be opened based on failure rate
     */
    private shouldOpenCircuit;
    /**
     * Check if we should attempt to reset from open state
     */
    private shouldAttemptReset;
    /**
     * Check if error should be ignored by circuit breaker
     */
    private shouldIgnoreError;
    /**
     * Clean up old metrics outside monitoring window
     */
    private cleanupOldMetrics;
    /**
     * Reset success count (called when transitioning from half-open to closed)
     */
    private resetSuccessCount;
    /**
     * Set circuit state and emit event
     */
    private setState;
    /**
     * Emit event to registered handlers
     */
    private emit;
}
/**
 * Decorator for automatic circuit breaker protection
 */
export declare function circuitBreaker(config?: Partial<CircuitBreakerConfig>): <T extends (...args: any[]) => Promise<any>>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
export {};
//# sourceMappingURL=CircuitBreaker.d.ts.map