/**
 * Error Handling Implementation using p-retry and p-timeout
 * Replaced with industry-standard error handling libraries for better maintainability
 *
 * Migration Guide:
 * - withErrorLogging() -> use p-retry + custom error logging
 * - safeExecute() -> p-timeout + try/catch
 * - withFallback() -> p-retry with fallback function
 * - Better retry strategies and timeout handling
 */
declare function getPRetry(): Promise<typeof import('p-retry')['default']>;
declare function getAbortError(): Promise<typeof import('p-retry')['AbortError']>;
declare function getPTimeout(): Promise<typeof import('p-timeout')['default']>;
export interface RetryOptions {
    retries?: number;
    factor?: number;
    minTimeout?: number;
    maxTimeout?: number;
    randomize?: boolean;
    shouldRetry?: (error: Error) => boolean;
}
export interface TimeoutOptions {
    milliseconds?: number;
    message?: string;
    fallback?: () => any;
}
export interface ErrorHandlingOptions extends RetryOptions, TimeoutOptions {
    enableLogging?: boolean;
    enableRetry?: boolean;
    enableTimeout?: boolean;
    context?: string;
}
/**
 * Enhanced error handling with retry and timeout support
 */
export declare class EnhancedErrorHandler {
    private options;
    constructor(options?: ErrorHandlingOptions);
    /**
     * Execute function with retry logic
     */
    executeWithRetry<T>(fn: () => Promise<T>): Promise<T>;
    /**
     * Execute function with timeout
     */
    executeWithTimeout<T>(fn: () => Promise<T>, customTimeout?: number): Promise<T>;
    /**
     * Execute function with both retry and timeout
     */
    executeWithRetryAndTimeout<T>(fn: () => Promise<T>): Promise<T>;
    /**
     * Execute function with fallback
     */
    executeWithFallback<T>(fn: () => Promise<T>, fallbackFn: () => Promise<T>): Promise<T>;
    /**
     * Safe execute with comprehensive error handling
     */
    safeExecute<T>(fn: () => Promise<T>): Promise<T | null>;
}
/**
 * Legacy compatibility functions for backward compatibility
 */
/**
 * Execute function with error logging
 */
export declare function withErrorLogging<T>(fn: () => Promise<T>, context?: string): Promise<T>;
/**
 * Execute function safely with error handling
 */
export declare function safeExecute<T>(fn: () => Promise<T>, context?: string, timeout?: number): Promise<T | null>;
/**
 * Execute function with fallback
 */
export declare function withFallback<T>(fn: () => Promise<T>, fallbackFn: () => Promise<T>, context?: string): Promise<T>;
/**
 * Execute function with async error logging
 */
export declare function withAsyncErrorLogging<T>(fn: () => Promise<T>, context?: string): Promise<T>;
/**
 * Execute function with retry logic
 */
export declare function withRetry<T>(fn: () => Promise<T>, retryOptions?: RetryOptions, context?: string): Promise<T>;
/**
 * Execute function with timeout
 */
export declare function withTimeout<T>(fn: () => Promise<T>, timeoutOptions?: TimeoutOptions, context?: string): Promise<T>;
export { getPRetry as pRetry, getPTimeout as pTimeout, getAbortError as AbortError };
export default EnhancedErrorHandler;
//# sourceMappingURL=pRetryTimeoutWrapper.d.ts.map