export declare class VisionError extends Error {
    readonly code: string;
    readonly context?: Record<string, any>;
    readonly recoverable: boolean;
    constructor(message: string, code: string, recoverable?: boolean, context?: Record<string, any>);
}
export declare class CameraError extends VisionError {
    constructor(message: string, context?: Record<string, any>);
}
export declare class ScreenCaptureError extends VisionError {
    constructor(message: string, context?: Record<string, any>);
}
export declare class ModelInitializationError extends VisionError {
    constructor(message: string, modelName: string, context?: Record<string, any>);
}
export declare class ProcessingError extends VisionError {
    constructor(message: string, context?: Record<string, any>);
}
export declare class ConfigurationError extends VisionError {
    constructor(message: string, context?: Record<string, any>);
}
export declare class APIError extends VisionError {
    readonly statusCode?: number;
    readonly endpoint?: string;
    constructor(message: string, statusCode?: number, endpoint?: string, context?: Record<string, any>);
}
export interface RecoveryStrategy {
    canRecover(error: VisionError): boolean;
    recover(error: VisionError): Promise<void>;
}
export declare class ErrorRecoveryManager {
    private strategies;
    private errorCounts;
    private readonly maxRetries;
    constructor();
    private registerDefaultStrategies;
    registerStrategy(errorCode: string, strategy: RecoveryStrategy): void;
    handleError(error: VisionError): Promise<boolean>;
    resetErrorCount(errorCode: string): void;
    resetAllCounts(): void;
}
export declare class CircuitBreaker {
    private readonly threshold;
    private readonly timeout;
    private readonly name;
    private failures;
    private lastFailureTime;
    private state;
    constructor(threshold: number, timeout: number, // 1 minute
    name: string);
    execute<T>(operation: () => Promise<T>): Promise<T>;
    private onSuccess;
    private onFailure;
    getState(): string;
    reset(): void;
}
export declare class VisionErrorHandler {
    private static instance;
    private recoveryManager;
    private circuitBreakers;
    private constructor();
    static getInstance(): VisionErrorHandler;
    getCircuitBreaker(name: string, threshold?: number, timeout?: number): CircuitBreaker;
    handle(error: any): Promise<boolean>;
    resetCircuitBreaker(name: string): void;
    resetAllCircuitBreakers(): void;
}