import { Logger } from '../types';
export declare enum ErrorCategory {
    AUTHENTICATION = "authentication",
    API_RATE_LIMIT = "api_rate_limit",
    API_NETWORK = "api_network",
    API_SERVER = "api_server",
    API_CLIENT = "api_client",
    FILE_SYSTEM = "file_system",
    VALIDATION = "validation",
    CONFIGURATION = "configuration",
    MEMORY = "memory",
    TIMEOUT = "timeout",
    UNKNOWN = "unknown"
}
export declare enum ErrorSeverity {
    LOW = "low",
    MEDIUM = "medium",
    HIGH = "high",
    CRITICAL = "critical"
}
export declare enum RecoveryStrategy {
    RETRY = "retry",
    SKIP = "skip",
    FALLBACK = "fallback",
    ABORT = "abort",
    MANUAL = "manual"
}
export interface ErrorContext {
    operation: string;
    documentId?: string;
    documentTitle?: string;
    folderPath?: string;
    filePath?: string;
    batchIndex?: number;
    attemptNumber?: number;
    timestamp: Date;
    metadata?: any;
}
export interface CategorizedError {
    originalError: Error;
    category: ErrorCategory;
    severity: ErrorSeverity;
    recoveryStrategy: RecoveryStrategy;
    context: ErrorContext;
    isRetryable: boolean;
    maxRetries: number;
    retryDelay: number;
    message: string;
    userMessage: string;
    technicalDetails: string;
}
export interface ErrorRecoveryResult {
    success: boolean;
    action: 'retry' | 'skip' | 'fallback' | 'abort';
    delay?: number;
    fallbackData?: any;
    message?: string;
}
export interface ErrorStatistics {
    totalErrors: number;
    errorsByCategory: Record<ErrorCategory, number>;
    errorsBySeverity: Record<ErrorSeverity, number>;
    retriedErrors: number;
    skippedErrors: number;
    abortedOperations: number;
    recoveredErrors: number;
}
export declare class ErrorHandler {
    private readonly logger;
    private readonly statistics;
    private readonly errorHistory;
    private readonly maxHistorySize;
    constructor(logger: Logger, maxHistorySize?: number);
    handleError(error: Error, context: ErrorContext): Promise<CategorizedError>;
    determineRecovery(categorizedError: CategorizedError): Promise<ErrorRecoveryResult>;
    shouldAbortOperation(): boolean;
    getStatistics(): ErrorStatistics;
    getRecentErrors(timeWindowMs: number): CategorizedError[];
    getErrorsByCategory(category: ErrorCategory): CategorizedError[];
    clearHistory(): void;
    generateErrorReport(): {
        summary: ErrorStatistics;
        recentErrors: CategorizedError[];
        recommendations: string[];
    };
    private categorizeError;
    private updateStatistics;
    private addToHistory;
    private logError;
    private calculateRetryDelay;
    private attemptFallback;
    private generateUserMessage;
    private generateTechnicalDetails;
    private generateRecommendations;
    private resetStatistics;
}
//# sourceMappingURL=error-handler.d.ts.map