/**
 * @file Resilience Utilities
 * @description Enterprise-grade retry policies, circuit breakers, and fault tolerance patterns
 */
/**
 * Retry policy configuration
 */
export interface RetryConfig {
    /** Maximum retry attempts */
    maxAttempts?: number;
    /** Initial delay between retries (ms) */
    initialDelay?: number;
    /** Maximum delay between retries (ms) */
    maxDelay?: number;
    /** Delay multiplier for exponential backoff */
    backoffMultiplier?: number;
    /** Whether to add jitter to delays */
    jitter?: boolean;
    /** Predicate to determine if error is retryable */
    retryOn?: (error: unknown, attempt: number) => boolean;
    /** Callback on each retry attempt */
    onRetry?: (error: unknown, attempt: number, delay: number) => void;
    /** Abort signal for cancellation */
    signal?: AbortSignal;
}
/**
 * Execute function with retry logic
 */
export declare function withRetry<T>(fn: () => Promise<T>, config?: RetryConfig): Promise<T>;
/**
 * Retry policy builder for fluent configuration
 */
export declare class RetryPolicy {
    private readonly config;
    constructor(config?: RetryConfig);
    /**
     * Set max attempts
     */
    attempts(max: number): RetryPolicy;
    /**
     * Set delays
     */
    delays(initial: number, max?: number): RetryPolicy;
    /**
     * Set backoff multiplier
     */
    backoff(multiplier: number): RetryPolicy;
    /**
     * Enable/disable jitter
     */
    withJitter(enabled?: boolean): RetryPolicy;
    /**
     * Set retry condition
     */
    retryIf(predicate: (error: unknown, attempt: number) => boolean): RetryPolicy;
    /**
     * Set retry callback
     */
    onRetry(callback: (error: unknown, attempt: number, delay: number) => void): RetryPolicy;
    /**
     * Execute with this policy
     */
    execute<T>(fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;
}
/**
 * Circuit breaker states
 */
export type CircuitState = 'closed' | 'open' | 'half-open';
/**
 * Circuit breaker configuration
 */
export interface CircuitBreakerConfig {
    /** Failure threshold before opening */
    failureThreshold?: number;
    /** Success threshold for half-open to close */
    successThreshold?: number;
    /** Time to wait before trying half-open (ms) */
    resetTimeout?: number;
    /** Time window for failure counting (ms) */
    failureWindow?: number;
    /** Callback on state change */
    onStateChange?: (from: CircuitState, to: CircuitState) => void;
}
/**
 * Circuit breaker for fault isolation
 */
export declare class CircuitBreaker {
    private state;
    private failures;
    private successes;
    private lastFailureTime;
    private config;
    constructor(config?: CircuitBreakerConfig);
    /**
     * Get current circuit state
     */
    getState(): CircuitState;
    /**
     * Record success
     */
    success(): void;
    /**
     * Record failure
     */
    failure(): void;
    /**
     * Execute function through circuit breaker
     */
    execute<T>(fn: () => Promise<T>): Promise<T>;
    /**
     * Get circuit statistics
     */
    getStats(): {
        state: CircuitState;
        failures: number;
        successesInHalfOpen: number;
        lastFailure: Date | null;
    };
    /**
     * Force reset the circuit
     */
    reset(): void;
    /**
     * Check if reset should be attempted
     */
    private shouldAttemptReset;
    /**
     * Transition to new state
     */
    private transition;
    /**
     * Clean failures outside window
     */
    private cleanOldFailures;
}
/**
 * Error thrown when circuit is open
 */
export declare class CircuitOpenError extends Error {
    readonly isCircuitOpen = true;
    constructor(message?: string);
}
/**
 * Bulkhead pattern for resource isolation
 */
export declare class Bulkhead {
    private running;
    private queue;
    private readonly maxConcurrent;
    private readonly maxQueue;
    constructor(maxConcurrent: number, maxQueue?: number);
    /**
     * Execute function with bulkhead isolation
     */
    execute<T>(fn: () => Promise<T>): Promise<T>;
    /**
     * Get bulkhead statistics
     */
    getStats(): {
        running: number;
        queued: number;
        maxConcurrent: number;
        maxQueue: number;
        available: number;
    };
    /**
     * Clear the queue (reject all pending)
     */
    clearQueue(): void;
}
/**
 * Error thrown when bulkhead is full
 */
export declare class BulkheadFullError extends Error {
    readonly isBulkheadFull = true;
    constructor(message?: string);
}
/**
 * Timeout wrapper
 */
export declare function withTimeout<T>(fn: () => Promise<T>, timeout: number, timeoutError?: Error): Promise<T>;
/**
 * Timeout error
 */
export declare class TimeoutError extends Error {
    readonly isTimeout = true;
    constructor(message?: string);
}
/**
 * Fallback wrapper
 */
export declare function withFallback<T>(fn: () => Promise<T>, fallback: T | (() => T | Promise<T>)): Promise<T>;
/**
 * Compose multiple resilience patterns
 */
export declare function compose<T>(fn: () => Promise<T>, ...wrappers: Array<(fn: () => Promise<T>) => Promise<T>>): () => Promise<T>;
/**
 * Create a resilient function with all patterns
 */
export declare function createResilientFn<Args extends unknown[], Result>(fn: (...args: Args) => Promise<Result>, options?: {
    retry?: RetryConfig;
    circuitBreaker?: CircuitBreaker;
    bulkhead?: Bulkhead;
    timeout?: number;
    fallback?: Result | (() => Result | Promise<Result>);
}): (...args: Args) => Promise<Result>;
/**
 * Predefined retry policies
 */
export declare const retryPolicies: {
    /** No retry */
    none: RetryPolicy;
    /** Quick retry (3 attempts, 100ms start) */
    quick: RetryPolicy;
    /** Standard retry (3 attempts, 1s start) */
    standard: RetryPolicy;
    /** Extended retry (5 attempts, 2s start) */
    extended: RetryPolicy;
    /** Network retry (retry on network errors) */
    network: RetryPolicy;
};