@allan1361/iota-big3-sdk-middleware/dist/types/resilience.d.ts

🏆 A+ Grade Certified Enterprise Middleware Framework - Phase 3 Certified (90/100) with advanced resilience patterns, comprehensive type safety, and production-ready observability

import type { Request, Response } from 'express';
import type { JsonObject, MiddlewareFunction } from './types';
export declare enum CircuitBreakerState {
    CLOSED = "CLOSED",
    OPEN = "OPEN",
    HALF_OPEN = "HALF_OPEN"
}
export interface CircuitBreakerConfig {
    failureThreshold: number;
    recoveryTimeout: number;
    monitoringPeriod: number;
    halfOpenMaxCalls: number;
}
export interface RetryConfig {
    maxAttempts: number;
    backoffMultiplier: number;
    maxBackoffMs: number;
    retryableErrors: string[];
}
export interface TimeoutConfig {
    timeoutMs: number;
    timeoutMessage: string;
}
export interface HealthCheckConfig {
    intervalMs: number;
    unhealthyThreshold: number;
    healthyThreshold: number;
}
export declare class CircuitBreaker {
    private config;
    private state;
    private failureCount;
    private successCount;
    private lastFailureTime;
    private halfOpenCalls;
    constructor(config: CircuitBreakerConfig);
    execute<T>(operation: () => Promise<T>): Promise<T>;
    private onSuccess;
    private onFailure;
    getStatus(): {
        state: CircuitBreakerState;
        failureCount: number;
        successCount: number;
    };
}
export declare class RetryHandler {
    private config;
    constructor(config: RetryConfig);
    execute<T>(operation: () => Promise<T>): Promise<T>;
    private isRetryableError;
    private delay;
}
export declare class TimeoutHandler {
    private config;
    constructor(config: TimeoutConfig);
    execute<T>(operation: () => Promise<T>): Promise<T>;
}
export declare class HealthMonitor {
    private config;
    private healthChecks;
    private healthStatus;
    private monitoringInterval?;
    constructor(config: HealthCheckConfig);
    addHealthCheck(name: string, checkFn: () => Promise<boolean>): void;
    removeHealthCheck(name: string): void;
    startMonitoring(): void;
    stopMonitoring(): void;
    private runHealthChecks;
    private updateHealthStatus;
    getOverallHealth(): {
        healthy: boolean;
        checks: JsonObject;
    };
}
export declare class ResilientMiddlewareFactory {
    private circuitBreakers;
    private healthMonitor;
    constructor(healthConfig: HealthCheckConfig);
    createResilientMiddleware(name: string, operation: (req: Request, res: Response) => Promise<void>, options?: {
        circuitBreaker?: CircuitBreakerConfig;
        retry?: RetryConfig;
        timeout?: TimeoutConfig;
    }): MiddlewareFunction;
    createHealthCheckMiddleware(): MiddlewareFunction;
    getHealthMonitor(): HealthMonitor;
    shutdown(): void;
}
export declare function createResilientMiddleware(healthConfig?: HealthCheckConfig): ResilientMiddlewareFactory;
//# sourceMappingURL=resilience.d.ts.map