import { CircuitState } from '../utils/resilience';
/**
 * Realtime circuit breaker configuration
 */
export interface RealtimeCircuitBreakerConfig {
    /** Failure threshold before opening circuit */
    failureThreshold?: number;
    /** Success threshold for half-open to close */
    successThreshold?: number;
    /** Time to wait before trying half-open (ms) */
    resetTimeout?: number;
    /** Time window for failure counting (ms) */
    failureWindow?: number;
    /** Connection timeout (ms) */
    connectionTimeout?: number;
    /** Whether to enable health checking */
    healthCheckEnabled?: boolean;
    /** Health check interval (ms) */
    healthCheckInterval?: number;
    /** Callback on state change */
    onStateChange?: (from: CircuitState, to: CircuitState) => void;
    /** Callback when circuit opens (for fallback logic) */
    onCircuitOpen?: () => void;
    /** Callback when circuit recovers */
    onCircuitRecovery?: () => void;
}
/**
 * Connection state
 */
export type RealtimeConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'circuit_open' | 'degraded';
/**
 * Connection metrics
 */
export interface RealtimeConnectionMetrics {
    consecutiveFailures: number;
    totalFailures: number;
    totalSuccesses: number;
    lastFailureTime: Date | null;
    lastSuccessTime: Date | null;
    circuitState: CircuitState;
    connectionState: RealtimeConnectionState;
    averageReconnectTime: number;
}
/**
 * Realtime circuit breaker for WebSocket/SSE connections
 *
 * This class provides fault isolation for realtime connections:
 * - Prevents connection storms during outages
 * - Provides graceful degradation when services are unavailable
 * - Tracks connection health metrics
 * - Supports fallback to alternative transports
 */
export declare class RealtimeCircuitBreaker {
    private breaker;
    private config;
    private connectionState;
    private consecutiveFailures;
    private totalFailures;
    private totalSuccesses;
    private lastFailureTime;
    private lastSuccessTime;
    private reconnectTimes;
    private healthCheckTimer;
    private connectionStartTime;
    private disposed;
    constructor(config?: RealtimeCircuitBreakerConfig);
    /**
     * Get current circuit state
     */
    getCircuitState(): CircuitState;
    /**
     * Get current connection state
     */
    getConnectionState(): RealtimeConnectionState;
    /**
     * Check if connection is allowed
     */
    canConnect(): boolean;
    /**
     * Check if circuit is open
     */
    isCircuitOpen(): boolean;
    /**
     * Execute a connection attempt through the circuit breaker
     */
    connect<T>(connectionFactory: () => Promise<T>, options?: {
        timeout?: number;
    }): Promise<T>;
    /**
     * Record a successful connection
     */
    recordSuccess(): void;
    /**
     * Record a connection failure
     */
    recordFailure(): void;
    /**
     * Record a disconnect event (not necessarily a failure)
     */
    recordDisconnect(): void;
    /**
     * Get connection metrics
     */
    getMetrics(): RealtimeConnectionMetrics;
    /**
     * Start health checking (for monitoring purposes)
     */
    startHealthCheck(checkFn: () => Promise<boolean>): void;
    /**
     * Stop health checking
     */
    stopHealthCheck(): void;
    /**
     * Force reset the circuit breaker
     */
    reset(): void;
    /**
     * Dispose the circuit breaker
     */
    dispose(): void;
    /**
     * Handle circuit state changes
     */
    private handleCircuitStateChange;
    /**
     * Apply timeout to connection factory
     */
    private withConnectionTimeout;
}
/**
 * Connection timeout error
 */
export declare class ConnectionTimeoutError extends Error {
    readonly isConnectionTimeout = true;
    constructor(message?: string);
}
/**
 * Create a WebSocket-specific circuit breaker
 */
export declare function createWebSocketCircuitBreaker(config?: RealtimeCircuitBreakerConfig): RealtimeCircuitBreaker;
/**
 * Create an SSE-specific circuit breaker
 */
export declare function createSSECircuitBreaker(config?: RealtimeCircuitBreakerConfig): RealtimeCircuitBreaker;
/**
 * Get or create a named circuit breaker
 */
export declare function getRealtimeCircuitBreaker(name: string, config?: RealtimeCircuitBreakerConfig): RealtimeCircuitBreaker;
/**
 * Reset all circuit breakers
 */
export declare function resetAllRealtimeCircuitBreakers(): void;
/**
 * Get all circuit breaker metrics
 */
export declare function getAllRealtimeCircuitBreakerMetrics(): Record<string, RealtimeConnectionMetrics>;
/**
 * Dispose all circuit breakers
 */
export declare function disposeAllRealtimeCircuitBreakers(): void;