export interface RetryOptions {
    maxRetries?: number;
    baseDelay?: number;
    maxDelay?: number;
    backoffMultiplier?: number;
    jitter?: boolean;
    retryableErrors?: string[];
    onRetry?: (attempt: number, error: Error) => void;
}
export interface RetryResult<T> {
    result: T;
    attempts: number;
    totalDelay: number;
}
export declare class RetryHandler {
    static withRetry<T>(operation: () => Promise<T>, options?: RetryOptions): Promise<RetryResult<T>>;
    static withExponentialBackoff<T>(operation: () => Promise<T>, options?: RetryOptions): Promise<T>;
    static withLinearBackoff<T>(operation: () => Promise<T>, options?: RetryOptions): Promise<T>;
    private static shouldRetry;
    private static calculateDelay;
    private static sleep;
    static wrap<T extends (...args: any[]) => Promise<any>>(fn: T, options?: RetryOptions): T;
}
export interface CircuitBreakerOptions {
    failureThreshold?: number;
    recoveryDelay?: number;
    monitoringPeriod?: number;
    onStateChange?: (state: 'CLOSED' | 'OPEN' | 'HALF_OPEN') => void;
}
export declare class CircuitBreaker {
    private options;
    private state;
    private failureCount;
    private lastFailureTime;
    private successCount;
    constructor(options?: CircuitBreakerOptions);
    execute<T>(operation: () => Promise<T>): Promise<T>;
    private onSuccess;
    private onFailure;
    private setState;
    getState(): 'CLOSED' | 'OPEN' | 'HALF_OPEN';
    getFailureCount(): number;
    getSuccessCount(): number;
    reset(): void;
}
export declare class Bulkhead {
    private maxConcurrency;
    private running;
    private queue;
    constructor(maxConcurrency: number);
    execute<T>(operation: () => Promise<T>): Promise<T>;
    private process;
    getRunningCount(): number;
    getQueueLength(): number;
}
//# sourceMappingURL=retry.d.ts.map