import { PresentationError, SessionError, NetworkError, ConnectionError, BotError, ConfigError, UserMessage } from '../types/errors';
/**
 * Error handler configuration
 */
export interface ErrorHandlerConfig {
    /**
     * Callback for error events
     */
    onError?: (error: PresentationError) => void;
    /**
     * Callback for recovery attempts
     */
    onRecoveryAttempt?: (error: PresentationError, attempt: number) => void;
    /**
     * Callback for successful recovery
     */
    onRecoverySuccess?: (error: PresentationError) => void;
    /**
     * Callback for failed recovery
     */
    onRecoveryFailure?: (error: PresentationError) => void;
    /**
     * Maximum retry attempts for recoverable errors
     * @default 3
     */
    maxRetries?: number;
    /**
     * Delay between retry attempts in milliseconds
     * @default 1000
     */
    retryDelay?: number;
    /**
     * Enable exponential backoff for retries
     * @default true
     */
    exponentialBackoff?: boolean;
    /**
     * Enable debug logging
     * @default false
     */
    debug?: boolean;
}
/**
 * Error handling context
 */
export interface ErrorContext {
    /**
     * Operation that caused the error
     */
    operation: string;
    /**
     * Additional context data
     */
    context?: Record<string, unknown>;
    /**
     * Custom recovery function
     */
    recoveryFn?: () => Promise<void>;
}
/**
 * Error handling result
 */
export interface ErrorHandlingResult {
    /**
     * Whether the error was handled successfully
     */
    handled: boolean;
    /**
     * Whether the operation should be retried
     */
    shouldRetry: boolean;
    /**
     * User-facing message
     */
    userMessage?: UserMessage;
    /**
     * The error that was handled
     */
    error?: PresentationError;
    /**
     * Whether recovery was attempted
     */
    recoveryAttempted?: boolean;
    /**
     * Whether recovery succeeded
     */
    recoverySucceeded?: boolean;
    /**
     * Number of recovery attempts made
     */
    recoveryAttempts?: number;
}
/**
 * Error handler class
 */
export declare class ErrorHandler {
    private readonly config;
    private retryCount;
    constructor(config?: ErrorHandlerConfig);
    /**
     * Handle an error with recovery strategy
     */
    handle(error: unknown, context: ErrorContext): Promise<ErrorHandlingResult>;
    /**
     * Attempt to recover from an error
     */
    private attemptRecovery;
    /**
     * Calculate retry delay with optional exponential backoff
     */
    private calculateRetryDelay;
    /**
     * Convert unknown error to PresentationError
     */
    private toPresentationError;
    /**
     * Create PresentationError from standard Error
     */
    private createErrorFromStandardError;
    /**
     * Get user-friendly message for HTTP status codes
     */
    private getAPIErrorMessage;
    /**
     * Sleep for a given number of milliseconds
     */
    private sleep;
    /**
     * Debug logging
     */
    private log;
    /**
     * Reset retry count for an operation
     */
    resetRetryCount(operation: string): void;
    /**
     * Get retry count for an operation
     */
    getRetryCount(operation: string): number;
}
/**
 * Create common session errors
 */
export declare const createSessionCreationError: (cause?: Error) => SessionError;
/**
 * Create room connection error
 */
export declare const createRoomConnectionError: (cause?: Error) => ConnectionError;
/**
 * Create bot spawn error
 */
export declare const createBotSpawnError: (botType: string, cause?: Error) => BotError;
/**
 * Create network timeout error
 */
export declare const createNetworkTimeoutError: (cause?: Error) => NetworkError;
/**
 * Create configuration error
 */
export declare const createConfigError: (configKey: string, cause?: Error) => ConfigError;