@sirmrmarty/n8n-nodes-tmux-orchestrator/dist/utils/circuitBreaker.d.ts

n8n nodes for orchestrating Claude AI agents through tmux sessions

export declare enum CircuitState {
    CLOSED = "CLOSED",
    OPEN = "OPEN",
    HALF_OPEN = "HALF_OPEN"
}
export interface CircuitBreakerConfig {
    failureThreshold?: number;
    recoveryTimeout?: number;
    successThreshold?: number;
    monitoringWindow?: number;
    maxRetryAttempts?: number;
    exponentialBackoff?: boolean;
    onStateChange?: (state: CircuitState, reason: string) => void;
    onFailure?: (error: Error) => void;
    onSuccess?: () => void;
}
export interface CircuitBreakerStats {
    state: CircuitState;
    failures: number;
    successes: number;
    totalCalls: number;
    failureRate: number;
    lastFailureTime?: number;
    lastSuccessTime?: number;
    uptime: number;
    stateChanges: number;
}
export interface FailureRecord {
    timestamp: number;
    error: string;
    attempts: number;
}
export declare class CircuitBreaker {
    private name;
    private state;
    private failures;
    private successes;
    private totalCalls;
    private lastFailureTime?;
    private lastSuccessTime?;
    private nextAttemptTime;
    private stateChanges;
    private createdAt;
    private config;
    private recentFailures;
    private recoveryTimer?;
    constructor(name: string, config?: CircuitBreakerConfig);
    execute<T>(operation: () => Promise<T>, fallback?: () => Promise<T> | T): Promise<T>;
    private executeWithRetry;
    private onSuccess;
    private onFailure;
    private setState;
    private scheduleRecovery;
    private resetCounters;
    open(reason?: string): void;
    close(reason?: string): void;
    getStats(): CircuitBreakerStats;
    getFailureHistory(): FailureRecord[];
    isHealthy(): boolean;
    destroy(): void;
}
export declare class CircuitBreakerRegistry {
    private static instance;
    private breakers;
    private constructor();
    static getInstance(): CircuitBreakerRegistry;
    getBreaker(name: string, config?: CircuitBreakerConfig): CircuitBreaker;
    removeBreaker(name: string): boolean;
    getAllStats(): Record<string, CircuitBreakerStats>;
    getHealthStatus(): {
        healthy: string[];
        unhealthy: string[];
    };
    emergencyStop(): void;
    resetAll(): void;
    destroy(): void;
}
export declare const circuitRegistry: CircuitBreakerRegistry;