/**
 * ActionRetryHandler - Robust error handling and retry logic for actions
 */
import { ActionResult } from '../types';
/**
 * Retry configuration
 */
export interface RetryConfig {
    maxRetries: number;
    retryDelay: number;
    exponentialBackoff: boolean;
    retryableErrors: string[];
}
/**
 * Error classification
 */
export declare enum ErrorType {
    TRANSIENT = "transient",// Can be retried
    PERMANENT = "permanent",// Cannot be retried
    RATE_LIMIT = "rate_limit",// Rate limited, needs longer delay
    PERMISSION = "permission",// Permission denied
    NOT_FOUND = "not_found",// Resource not found
    INVALID_INPUT = "invalid_input",// Invalid parameters
    NETWORK = "network",// Network error
    TIMEOUT = "timeout"
}
/**
 * Enhanced action result with retry metadata
 */
export interface EnhancedActionResult extends ActionResult {
    errorType?: ErrorType;
    retryable?: boolean;
    retryCount?: number;
    executionTime?: number;
}
/**
 * ActionRetryHandler - Handles retries and error recovery
 */
export declare class ActionRetryHandler {
    private config;
    private defaultConfig;
    constructor(config?: Partial<RetryConfig>);
    /**
     * Execute an action with retry logic
     */
    executeWithRetry<T>(actionFn: () => Promise<T>, actionName: string, retryConfig?: Partial<RetryConfig>): Promise<T>;
    /**
     * Classify error type
     */
    classifyError(error: Error): ErrorType;
    /**
     * Check if error is retryable
     */
    isRetryableError(errorType: ErrorType, errorMessage: string): boolean;
    /**
     * Enhance action result with error metadata
     */
    enhanceResult(result: ActionResult, error?: Error, retryCount?: number): EnhancedActionResult;
    /**
     * Create a user-friendly error message
     */
    formatErrorForUser(error: Error, errorType: ErrorType, actionName: string): string;
    /**
     * Sleep for specified milliseconds
     */
    private sleep;
}
/**
 * Circuit breaker pattern for preventing cascading failures
 */
export declare class CircuitBreaker {
    private threshold;
    private resetTimeout;
    private failureCount;
    private lastFailureTime;
    private state;
    constructor(threshold?: number, _timeout?: number, // 1 minute (reserved for future use)
    resetTimeout?: number);
    /**
     * Execute function with circuit breaker protection
     */
    execute<T>(fn: () => Promise<T>): Promise<T>;
    /**
     * Get current circuit breaker state
     */
    getState(): {
        state: string;
        failureCount: number;
        lastFailureTime: number;
    };
    /**
     * Manually reset the circuit breaker
     */
    reset(): void;
}
//# sourceMappingURL=ActionRetryHandler.d.ts.map