/**
 * @file circuit-breaker.ts
 * @description Circuit breaker pattern for preventing cascading failures in remote MCP operations
 */
export type CircuitState = 'closed' | 'open' | 'half-open';
export interface CircuitBreakerOptions {
    /** Number of failures before opening circuit (default: 5) */
    failureThreshold?: number;
    /** Time in ms before attempting to close circuit (default: 30000) */
    resetTimeoutMs?: number;
    /** Number of successful calls in half-open to close circuit (default: 2) */
    successThreshold?: number;
    /** Time window in ms for counting failures (default: 60000) */
    failureWindowMs?: number;
    /** Callback when state changes */
    onStateChange?: (state: CircuitState, previousState: CircuitState) => void;
}
/**
 * Circuit breaker for a specific remote app connection.
 *
 * States:
 * - CLOSED: Normal operation, requests pass through
 * - OPEN: Failures exceeded threshold, requests fail immediately
 * - HALF-OPEN: Testing if service recovered, limited requests allowed
 */
export declare class CircuitBreaker {
    private readonly appId;
    private readonly options;
    private state;
    private failures;
    private successCount;
    private lastFailureTime?;
    private nextAttemptTime?;
    constructor(appId: string, options?: CircuitBreakerOptions);
    /**
     * Get current circuit state
     */
    getState(): CircuitState;
    /**
     * Check if the circuit allows requests
     */
    canExecute(): boolean;
    /**
     * Record a successful operation
     */
    recordSuccess(): void;
    /**
     * Record a failed operation
     */
    recordFailure(error: Error): void;
    /**
     * Force reset the circuit to closed state
     */
    reset(): void;
    /**
     * Get circuit breaker stats
     */
    getStats(): {
        state: CircuitState;
        failureCount: number;
        successCount: number;
        lastFailureTime?: number;
        nextAttemptTime?: number;
    };
    private transitionTo;
    private cleanOldFailures;
}
/**
 * Error thrown when circuit is open
 */
export declare class CircuitOpenError extends Error {
    readonly appId: string;
    readonly nextAttemptTime?: number;
    constructor(appId: string, nextAttemptTime?: number);
}
/**
 * Manager for multiple circuit breakers (one per remote app)
 */
export declare class CircuitBreakerManager {
    private readonly breakers;
    private readonly defaultOptions;
    constructor(defaultOptions?: CircuitBreakerOptions);
    /**
     * Get or create a circuit breaker for an app
     */
    getBreaker(appId: string, options?: CircuitBreakerOptions): CircuitBreaker;
    /**
     * Remove a circuit breaker
     */
    removeBreaker(appId: string): void;
    /**
     * Reset all circuit breakers
     */
    resetAll(): void;
    /**
     * Get stats for all circuit breakers
     */
    getAllStats(): Map<string, ReturnType<CircuitBreaker['getStats']>>;
}
//# sourceMappingURL=circuit-breaker.d.ts.map