/**
 * @file Smart Error Recovery UX
 * @description PhD-level intelligent error recovery with automatic retry strategies,
 * user-friendly progress indication, and circuit breaker integration.
 *
 * Features:
 * - Automatic recovery strategies
 * - Intelligent retry logic with exponential backoff
 * - User-friendly progress indication
 * - Circuit breaker UX integration
 * - Network-aware recovery
 * - Graceful degradation messaging
 */
/**
 * Error severity levels
 */
export type RecoveryErrorSeverity = 'info' | 'warning' | 'error' | 'critical';
/**
 * Recovery strategy types
 */
export type RecoveryStrategy = 'retry' | 'refresh' | 'fallback' | 'redirect' | 'manual' | 'none';
/**
 * Recovery state
 */
export type RecoveryState = 'idle' | 'recovering' | 'recovered' | 'failed' | 'circuit-open';
/**
 * Recovery progress info
 */
export interface RecoveryProgress {
    /** Current state */
    state: RecoveryState;
    /** Current attempt number */
    attempt: number;
    /** Maximum attempts */
    maxAttempts: number;
    /** Progress percentage (0-100) */
    percentage: number;
    /** Time until next retry in ms */
    nextRetryIn: number;
    /** Error message */
    message: string;
    /** User-friendly suggestion */
    suggestion: string;
}
/**
 * Error classification result
 */
export interface ErrorClassification {
    /** Error severity */
    severity: RecoveryErrorSeverity;
    /** Is recoverable */
    recoverable: boolean;
    /** Recommended strategy */
    strategy: RecoveryStrategy;
    /** Is network related */
    isNetworkError: boolean;
    /** Is rate limited */
    isRateLimited: boolean;
    /** Is authentication error */
    isAuthError: boolean;
    /** Is validation error */
    isValidationError: boolean;
    /** Retry delay suggestion in ms */
    suggestedRetryDelay: number;
}
/**
 * Recovery options
 */
export interface RecoveryOptions {
    /** Maximum retry attempts */
    maxAttempts?: number;
    /** Base delay between retries in ms */
    baseDelay?: number;
    /** Maximum delay between retries in ms */
    maxDelay?: number;
    /** Backoff multiplier */
    backoffMultiplier?: number;
    /** Add jitter to delays */
    jitter?: boolean;
    /** Retry only on specific errors */
    retryOn?: (error: Error) => boolean;
    /** Custom error classifier */
    classifier?: (error: Error) => ErrorClassification;
    /** On recovery attempt */
    onAttempt?: (attempt: number, error: Error) => void;
    /** On recovery success */
    onSuccess?: () => void;
    /** On recovery failure */
    onFailure?: (error: Error, attempts: number) => void;
    /** Respect circuit breaker state */
    respectCircuitBreaker?: boolean;
}
/**
 * Circuit breaker state
 */
export interface CircuitBreakerState {
    /** Is circuit open */
    isOpen: boolean;
    /** Failures count */
    failures: number;
    /** Last failure timestamp */
    lastFailure: number | null;
    /** Time until half-open in ms */
    resetIn: number;
}
/**
 * Default error classifier
 */
export declare function classifyRecoveryError(error: Error): ErrorClassification;
/**
 * Get user-friendly error message
 */
export declare function getUserFriendlyErrorMessage(classification: ErrorClassification): {
    message: string;
    suggestion: string;
};
/**
 * Smart recovery engine
 */
export declare class RecoveryEngine {
    private options;
    private circuitBreaker;
    private circuitBreakerThreshold;
    private circuitBreakerTimeout;
    constructor(options?: RecoveryOptions);
    /**
     * Execute with automatic recovery
     */
    execute<T>(operation: () => Promise<T>, onProgress?: (progress: RecoveryProgress) => void): Promise<T>;
    /**
     * Get circuit breaker state
     */
    getCircuitBreakerState(): CircuitBreakerState;
    /**
     * Reset circuit breaker
     */
    resetCircuitBreaker(): void;
    /**
     * Calculate retry delay with exponential backoff and jitter
     */
    private calculateDelay;
    /**
     * Delay helper
     */
    private delay;
}
/**
 * Hook for automatic error recovery
 */
export declare function useRecovery<T>(operation: () => Promise<T>, options?: RecoveryOptions & {
    enabled?: boolean;
}): {
    execute: () => Promise<T>;
    progress: RecoveryProgress;
    isRecovering: boolean;
    error: Error | null;
    reset: () => void;
};
/**
 * Hook for circuit breaker awareness
 */
export declare function useCircuitBreaker(options?: RecoveryOptions): {
    state: CircuitBreakerState;
    isOpen: boolean;
    reset: () => void;
};
/**
 * Hook for network-aware recovery
 */
export declare function useNetworkAwareRecovery<T>(operation: () => Promise<T>, options?: RecoveryOptions): {
    execute: () => Promise<T>;
    isOnline: boolean;
    isRecovering: boolean;
    progress: RecoveryProgress;
    error: Error | null;
};
/**
 * Create recovery engine
 */
export declare function createRecoveryEngine(options?: RecoveryOptions): RecoveryEngine;
/**
 * Execute with recovery
 */
export declare function executeWithRecovery<T>(operation: () => Promise<T>, options?: RecoveryOptions): Promise<T>;
declare const _default: {
    RecoveryEngine: typeof RecoveryEngine;
    classifyRecoveryError: typeof classifyRecoveryError;
    getUserFriendlyErrorMessage: typeof getUserFriendlyErrorMessage;
    createRecoveryEngine: typeof createRecoveryEngine;
    executeWithRecovery: typeof executeWithRecovery;
    useRecovery: typeof useRecovery;
    useCircuitBreaker: typeof useCircuitBreaker;
    useNetworkAwareRecovery: typeof useNetworkAwareRecovery;
};
export default _default;