import { AppError } from '../monitoring/errorTypes';
/**
 * Recovery strategy types
 */
export type RecoveryStrategy = 'retry' | 'fallback' | 'cache' | 'degrade' | 'skip' | 'escalate';
/**
 * Recovery context
 */
export interface RecoveryContext {
    error: AppError;
    operation: string;
    attempts: number;
    startTime: number;
    metadata?: Record<string, unknown>;
}
/**
 * Recovery result
 */
export interface RecoveryResult<T> {
    success: boolean;
    value?: T;
    strategy: RecoveryStrategy;
    recovered: boolean;
    error?: AppError;
}
/**
 * Recovery handler function
 */
export type RecoveryHandler<T> = (context: RecoveryContext) => Promise<RecoveryResult<T>> | RecoveryResult<T>;
/**
 * Recovery configuration
 */
export interface RecoveryConfig<T> {
    /** Maximum recovery attempts */
    maxAttempts?: number;
    /** Strategies to try in order */
    strategies?: RecoveryStrategy[];
    /** Custom handlers for each strategy */
    handlers?: Partial<Record<RecoveryStrategy, RecoveryHandler<T>>>;
    /** Fallback value */
    fallbackValue?: T | (() => T | Promise<T>);
    /** Cache key for cache strategy */
    cacheKey?: string;
    /** Degraded functionality */
    degradedFn?: () => T | Promise<T>;
    /** Should escalate condition */
    shouldEscalate?: (error: AppError, attempts: number) => boolean;
    /** On recovery callback */
    onRecovery?: (result: RecoveryResult<T>, context: RecoveryContext) => void;
}
/**
 * Error recovery manager
 */
export declare class ErrorRecovery<T> {
    private config;
    private cache;
    private readonly CACHE_TTL;
    constructor(config?: RecoveryConfig<T>);
    /**
     * Execute operation with recovery
     */
    execute(operation: () => Promise<T>, operationName: string, metadata?: Record<string, unknown>): Promise<T>;
    /**
     * Clear cache
     */
    clearCache(): void;
    /**
     * Try a specific recovery strategy
     */
    private tryStrategy;
    /**
     * Retry strategy
     */
    private retryStrategy;
    /**
     * Fallback strategy
     */
    private fallbackStrategy;
    /**
     * Cache strategy
     */
    private cacheStrategy;
    /**
     * Degrade strategy
     */
    private degradeStrategy;
    /**
     * Skip strategy
     */
    private skipStrategy;
    /**
     * Escalate strategy
     */
    private escalateStrategy;
    /**
     * Check if error is retryable
     */
    private isRetryableError;
}
/**
 * Recovery builder for fluent configuration
 */
export declare class RecoveryBuilder<T> {
    private config;
    /**
     * Set max attempts
     */
    maxAttempts(n: number): RecoveryBuilder<T>;
    /**
     * Set strategies
     */
    strategies(...strategies: RecoveryStrategy[]): RecoveryBuilder<T>;
    /**
     * Set fallback value
     */
    fallback(value: T | (() => T | Promise<T>)): RecoveryBuilder<T>;
    /**
     * Set cache key
     */
    cache(key: string): RecoveryBuilder<T>;
    /**
     * Set degraded function
     */
    degrade(fn: () => T | Promise<T>): RecoveryBuilder<T>;
    /**
     * Set custom handler
     */
    handler(strategy: RecoveryStrategy, handler: RecoveryHandler<T>): RecoveryBuilder<T>;
    /**
     * Set recovery callback
     */
    onRecovery(callback: (result: RecoveryResult<T>, context: RecoveryContext) => void): RecoveryBuilder<T>;
    /**
     * Build the recovery manager
     */
    build(): ErrorRecovery<T>;
    /**
     * Execute with configured recovery
     */
    execute(operation: () => Promise<T>, operationName: string, metadata?: Record<string, unknown>): Promise<T>;
}
/**
 * Create a recovery builder
 */
export declare function recover<T>(): RecoveryBuilder<T>;
/**
 * Graceful degradation wrapper
 */
export declare function withGracefulDegradation<T>(primaryFn: () => Promise<T>, fallbackFn: () => T | Promise<T>, options?: {
    shouldDegrade?: (error: unknown) => boolean;
    onDegrade?: (error: unknown) => void;
}): Promise<{
    value: T;
    degraded: boolean;
}>;
/**
 * Circuit breaker with fallback
 */
export declare function withCircuitFallback<T>(primaryFn: () => Promise<T>, fallbackFn: () => T | Promise<T>, options?: {
    failureThreshold?: number;
    resetTimeout?: number;
}): () => Promise<T>;
/**
 * Stale-while-revalidate pattern
 */
export declare function staleWhileRevalidate<T>(fetchFn: () => Promise<T>, options: {
    cacheKey: string;
    staleTime?: number;
    maxAge?: number;
    storage?: Storage;
}): () => Promise<T>;
/**
 * Automatic retry with exponential backoff
 */
export declare function autoRetry<T>(fn: () => Promise<T>, options?: {
    maxAttempts?: number;
    baseDelay?: number;
    maxDelay?: number;
    shouldRetry?: (error: unknown, attempt: number) => boolean;
    onRetry?: (error: unknown, attempt: number, delay: number) => void;
}): Promise<T>;
/**
 * Safe async operation wrapper
 */
export declare function safe<T>(fn: () => Promise<T>): Promise<[T, null] | [null, Error]>;
/**
 * Safe sync operation wrapper
 */
export declare function safeSync<T>(fn: () => T): [T, null] | [null, Error];