export interface RetryOptions {
    maxRetries: number;
    baseDelay: number;
    maxDelay: number;
    backoffMultiplier: number;
    jitter: boolean;
    retryCondition?: (error: Error) => boolean;
    onRetry?: (error: Error, attempt: number) => void;
}
export interface CircuitBreakerOptions {
    failureThreshold: number;
    resetTimeout: number;
    monitoringPeriod: number;
}
export declare class RetryUtility {
    private static readonly DEFAULT_OPTIONS;
    static withRetry<T>(fn: () => Promise<T>, options?: Partial<RetryOptions>): Promise<T>;
    private static calculateDelay;
    private static delay;
    static createRetryFunction<T>(options?: Partial<RetryOptions>): (fn: () => Promise<T>) => Promise<T>;
    static retryOnCondition<T>(fn: () => Promise<T>, condition: (error: Error) => boolean, maxRetries?: number): Promise<T>;
    static retryWithCustomDelay<T>(fn: () => Promise<T>, delayCalculator: (attempt: number) => number, maxRetries?: number): Promise<T>;
}
export declare class CircuitBreaker {
    private options;
    private state;
    private failureCount;
    private lastFailureTime;
    private successCount;
    constructor(options: CircuitBreakerOptions);
    execute<T>(fn: () => Promise<T>): Promise<T>;
    private onSuccess;
    private onFailure;
    getState(): 'CLOSED' | 'OPEN' | 'HALF_OPEN';
    getStats(): {
        state: string;
        failureCount: number;
        successCount: number;
        lastFailureTime: number;
    };
    reset(): void;
}
export declare class Bulkhead {
    private maxConcurrency;
    private activeRequests;
    private readonly queue;
    constructor(maxConcurrency: number);
    execute<T>(fn: () => Promise<T>): Promise<T>;
    private executeImmediately;
    private processQueue;
    getStats(): {
        activeRequests: number;
        queuedRequests: number;
        maxConcurrency: number;
    };
}
//# sourceMappingURL=retry-utility.d.ts.map