/**
 * Circuit Breaker pattern implementation
 *
 * States:
 * - CLOSED: Normal operation, requests flow through
 * - OPEN: Failures exceeded threshold, requests fail fast
 * - HALF_OPEN: Testing if service recovered, limited requests allowed
 *
 * Features:
 * - Per-node circuit breakers
 * - Configurable failure threshold
 * - Automatic recovery testing
 * - Success threshold for full recovery
 * - Event hooks for monitoring
 */
import type { CircuitBreakerConfig, CircuitBreakerState } from '@cogitator-ai/types';
/**
 * Circuit breaker state data
 */
interface CircuitBreakerData {
    state: CircuitBreakerState;
    failures: number;
    successes: number;
    lastFailure?: number;
    lastStateChange: number;
    halfOpenAttempts: number;
    totalFailures: number;
    totalSuccesses: number;
    consecutiveSuccesses: number;
}
/**
 * Circuit breaker event types
 */
export type CircuitBreakerEvent = {
    type: 'state_change';
    from: CircuitBreakerState;
    to: CircuitBreakerState;
    nodeId: string;
} | {
    type: 'success';
    nodeId: string;
    duration: number;
} | {
    type: 'failure';
    nodeId: string;
    error: Error;
} | {
    type: 'rejected';
    nodeId: string;
    reason: string;
};
/**
 * Circuit breaker event handler
 */
export type CircuitBreakerEventHandler = (event: CircuitBreakerEvent) => void;
export declare class CircuitBreaker {
    private config;
    private breakers;
    private eventHandlers;
    constructor(config?: Partial<CircuitBreakerConfig>);
    /**
     * Get or create circuit breaker data for a node
     */
    private getBreaker;
    /**
     * Change circuit state
     */
    private changeState;
    /**
     * Check if request should be allowed
     */
    canExecute(nodeId: string): boolean;
    /**
     * Execute a function with circuit breaker protection
     */
    execute<T>(nodeId: string, fn: () => Promise<T>): Promise<T>;
    /**
     * Record a successful execution
     */
    recordSuccess(nodeId: string, duration?: number): void;
    /**
     * Record a failed execution
     */
    recordFailure(nodeId: string, error: Error): void;
    /**
     * Get current state for a node
     */
    getState(nodeId: string): CircuitBreakerState;
    /**
     * Get detailed stats for a node
     */
    getStats(nodeId: string): CircuitBreakerStats;
    /**
     * Get all node stats
     */
    getAllStats(): Map<string, CircuitBreakerStats>;
    /**
     * Force circuit state (for testing/admin)
     */
    forceState(nodeId: string, state: CircuitBreakerState): void;
    /**
     * Reset a circuit breaker
     */
    reset(nodeId: string): void;
    /**
     * Reset all circuit breakers
     */
    resetAll(): void;
    /**
     * Add event handler
     */
    onEvent(handler: CircuitBreakerEventHandler): () => void;
    /**
     * Emit event to all handlers
     */
    private emit;
}
/**
 * Circuit breaker stats
 */
export interface CircuitBreakerStats {
    nodeId: string;
    state: CircuitBreakerState;
    failures: number;
    successes: number;
    totalFailures: number;
    totalSuccesses: number;
    consecutiveSuccesses: number;
    lastFailure?: number;
    lastStateChange: number;
    timeInState: number;
    timeUntilReset?: number;
}
/**
 * Error thrown when circuit breaker is open
 */
export declare class CircuitBreakerOpenError extends Error {
    readonly nodeId: string;
    readonly state: CircuitBreakerState;
    readonly failures: number;
    readonly lastFailure?: number;
    constructor(nodeId: string, breaker: CircuitBreakerData);
}
/**
 * Create a circuit breaker instance
 */
export declare function createCircuitBreaker(config?: Partial<CircuitBreakerConfig>): CircuitBreaker;
/**
 * Decorator for circuit breaker protected methods
 */
export declare function WithCircuitBreaker(breaker: CircuitBreaker, nodeId: string): (_target: unknown, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
export {};
//# sourceMappingURL=circuit-breaker.d.ts.map