/**
 * Graduated Circuit Breaker
 * Routes traffic away from failing providers with confidence-weighted degradation.
 */
import type { CircuitBreakerConfig, CircuitBreakerState } from '../types.js';
import type { Logger } from './logger.js';
export interface CircuitBreakerSnapshot {
    version: 1;
    name: string;
    config: CircuitBreakerConfig;
    state: {
        consecutiveFailures: number;
        totalFailures: number;
        totalSuccesses: number;
        totalRequests: number;
        lastFailureAt?: number;
        lastSuccessAt?: number;
        lastRequestAt?: number;
        lastDecayAt: number;
        windowStart: number;
    };
}
export interface CircuitBreakerManagerSnapshot {
    version: 1;
    defaultConfig: CircuitBreakerConfig;
    breakers: CircuitBreakerSnapshot[];
}
export declare class CircuitBreaker {
    readonly name: string;
    private config;
    private readonly logger;
    private consecutiveFailures;
    private totalFailures;
    private totalSuccesses;
    private totalRequests;
    private lastFailureAt?;
    private lastSuccessAt?;
    private lastRequestAt?;
    private lastDecayAt;
    private windowStart;
    constructor(name: string, config?: Partial<CircuitBreakerConfig>, logger?: Logger);
    /**
     * Backwards-compatible execute alias.
     */
    execute<T>(fn: () => Promise<T>): Promise<T>;
    /**
     * Execute the primary operation if the breaker allows traffic through.
     * Rejected requests throw CircuitBreakerOpenError so callers can route elsewhere.
     */
    exec<T>(fn: () => Promise<T>): Promise<T>;
    /**
     * Execute with graduated fallback. Degraded traffic is routed to the fallback
     * probabilistically, and primary failures immediately fail over.
     */
    execWithFallback<T>(primary: () => Promise<T>, fallback: () => Promise<T>): Promise<T>;
    /**
     * Current percentage of traffic that should be routed to the primary provider.
     */
    primaryTrafficPct(): number;
    /**
     * Get current state and breaker statistics.
     */
    getState(): CircuitBreakerState;
    /**
     * Alias for stats-oriented call sites.
     */
    getStats(): CircuitBreakerState;
    /**
     * Get current configuration.
     */
    getConfig(): CircuitBreakerConfig;
    /**
     * Serialize breaker state for persistence in Workers KV, D1, Redis, etc.
     */
    serialize(): string;
    /**
     * Restore breaker state onto this instance.
     */
    restore(snapshot: CircuitBreakerSnapshot | string): void;
    static deserialize(json: string, logger?: Logger): CircuitBreaker;
    /**
     * Manual reset for testing and operator intervention.
     */
    reset(): void;
    /**
     * Force the breaker into the fully open state.
     */
    forceOpen(): void;
    isOpen(): boolean;
    isClosed(): boolean;
    /**
     * Deprecated alias retained for compatibility with the prior state machine.
     */
    isHalfOpen(): boolean;
    isDegraded(): boolean;
    isRecovering(): boolean;
    getHealth(): {
        state: CircuitBreakerState['state'];
        failures: number;
        consecutiveFailures: number;
        failureThreshold: number;
        primaryTrafficPct: number;
        healthy: boolean;
        lastFailure?: number;
        lastSuccess?: number;
        nextAttempt?: number;
        totalFailures: number;
        totalSuccesses: number;
        totalRequests: number;
    };
    private snapshot;
    private persistenceSnapshot;
    private currentState;
    private currentPrimaryTrafficPct;
    private buildOpenError;
    private retryAfterSec;
    private retryAt;
    private syncState;
    private markTraffic;
    private onSuccess;
    private onFailure;
    private maybeDecayFailures;
    private maybeRotateWindow;
}
/**
 * Circuit breaker manager for multiple providers.
 */
export declare class CircuitBreakerManager {
    private breakers;
    private defaultConfig;
    private logger;
    constructor(defaultConfig?: Partial<CircuitBreakerConfig>, logger?: Logger);
    getBreaker(name: string, config?: Partial<CircuitBreakerConfig>): CircuitBreaker;
    execute<T>(name: string, fn: () => Promise<T>, config?: Partial<CircuitBreakerConfig>): Promise<T>;
    execWithFallback<T>(name: string, primary: () => Promise<T>, fallback: () => Promise<T>, config?: Partial<CircuitBreakerConfig>): Promise<T>;
    getAllStates(): Record<string, CircuitBreakerState>;
    getHealthStatus(): Record<string, ReturnType<CircuitBreaker['getHealth']>>;
    /**
     * Snapshot all managed breakers for external persistence.
     */
    snapshot(): CircuitBreakerManagerSnapshot;
    /**
     * Serialize all managed breaker state for Workers KV, D1, Redis, etc.
     */
    serialize(): string;
    /**
     * Restore all managed breaker state onto this manager.
     */
    restore(snapshot: CircuitBreakerManagerSnapshot | string): void;
    static deserialize(json: string, logger?: Logger): CircuitBreakerManager;
    resetAll(): void;
    reset(name: string): void;
}
/**
 * Default circuit breaker manager instance.
 */
export declare const defaultCircuitBreakerManager: CircuitBreakerManager;
//# sourceMappingURL=circuit-breaker.d.ts.map