import { OfflineCache } from '../cache/OfflineCache';
import { PrintQueue } from '../queue/PrintQueue';
import { EventEmitter } from '../core/EventEmitter';
/**
 * Scheduled retry entry
 */
export interface ScheduledRetry {
    /** Job ID to retry */
    jobId: string;
    /** Scheduled execution time */
    runAt: Date;
    /** Current attempt count */
    attemptCount: number;
    /** Maximum retry attempts */
    maxAttempts: number;
    /** Base delay in ms for exponential backoff */
    baseDelay: number;
    /** Maximum delay in ms for exponential backoff */
    maxDelay: number;
    /** Last error message */
    lastError?: string;
    /** Scheduled timeout reference (internal, not serialized) */
    timeout?: ReturnType<typeof setTimeout>;
}
/**
 * Retry options
 */
export interface RetryOptions {
    /** Base delay in ms (default: 1000) */
    baseDelay?: number;
    /** Maximum delay in ms (default: 60000) */
    maxDelay?: number;
    /** Maximum attempts (default: 5) */
    maxAttempts?: number;
}
/**
 * Scheduler events
 */
export interface ScheduledRetryEvents {
    'retry-due': {
        entry: ScheduledRetry;
    };
    'retry-executed': {
        entry: ScheduledRetry;
        success: boolean;
    };
    'retry-cancelled': {
        jobId: string;
    };
    'retry-exhausted': {
        jobId: string;
    };
    'schedule-restored': {
        count: number;
    };
}
/**
 * Scheduled retry configuration
 */
export interface ScheduledRetryManagerConfig {
    /** Default base delay in ms */
    baseDelay: number;
    /** Default max delay in ms */
    maxDelay: number;
    /** Default max attempts */
    maxAttempts: number;
    /** Persist scheduled retries to OfflineCache */
    persistEnabled: boolean;
    /** Restore pending retries on startup */
    autoRestore: boolean;
}
/**
 * Scheduled Retry Manager
 *
 * Manages time-based retries for failed print jobs with support for:
 * - Scheduled execution at specific times
 * - Exponential backoff between retries
 * - Persistence across process restarts via OfflineCache
 * - Event-driven callbacks for retry execution
 */
export declare class ScheduledRetryManager extends EventEmitter<ScheduledRetryEvents> {
    protected readonly logger: {
        debug: (message: string, ...args: unknown[]) => void;
        info: (message: string, ...args: unknown[]) => void;
        warn: (message: string, ...args: unknown[]) => void;
        error: (message: string, ...args: unknown[]) => void;
    };
    /** Scheduled retries map: jobId -> ScheduledRetry */
    private readonly scheduledRetries;
    /** Configuration */
    private readonly config;
    /** Offline cache instance for persistence */
    private readonly offlineCache;
    /** Print queue reference for requeueing jobs */
    private printQueue;
    /** Retry executor function */
    private retryExecutor;
    /**
     * Creates a new ScheduledRetryManager instance
     *
     * @param config - Optional configuration overrides
     * @param offlineCache - Optional OfflineCache instance (uses singleton if not provided)
     */
    constructor(config?: Partial<ScheduledRetryManagerConfig>, offlineCache?: OfflineCache);
    /**
     * Set the print queue for job requeuing
     *
     * @param queue - PrintQueue instance
     */
    setPrintQueue(queue: PrintQueue): void;
    /**
     * Set the retry executor function
     *
     * @param executor - Async function that executes the retry
     */
    setRetryExecutor(executor: (jobId: string) => Promise<void>): void;
    /**
     * Schedule a retry for a specific job at a given time
     *
     * @param jobId - Job identifier to retry
     * @param runAt - Date/time to execute the retry
     * @param options - Optional retry configuration
     */
    scheduleRetry(jobId: string, runAt: Date, options?: RetryOptions): void;
    /**
     * Schedule a retry with exponential backoff starting from now
     *
     * @param jobId - Job identifier to retry
     * @param options - Retry options including baseDelay, maxDelay, maxAttempts
     */
    scheduleRetryWithBackoff(jobId: string, options?: RetryOptions): void;
    /**
     * Cancel a scheduled retry
     *
     * @param jobId - Job identifier to cancel
     * @returns true if a retry was cancelled, false if not found
     */
    cancelRetry(jobId: string): boolean;
    /**
     * Get all scheduled retries
     *
     * @returns Array of scheduled retry entries (without timeout refs)
     */
    getScheduledRetries(): Array<{
        jobId: string;
        runAt: Date;
    }>;
    /**
     * Get a specific scheduled retry entry
     *
     * @param jobId - Job identifier
     * @returns Scheduled retry entry or undefined
     */
    getScheduledRetry(jobId: string): ScheduledRetry | undefined;
    /**
     * Check if a job has a scheduled retry
     *
     * @param jobId - Job identifier
     * @returns true if retry is scheduled
     */
    hasScheduledRetry(jobId: string): boolean;
    /**
     * Get count of scheduled retries
     *
     * @returns Number of pending scheduled retries
     */
    get pendingCount(): number;
    /**
     * Clear all scheduled retries
     */
    clearAll(): void;
    /**
     * Destroy the manager
     */
    destroy(): void;
    /**
     * Execute a scheduled retry
     */
    private executeRetry;
    /**
     * Persist a scheduled retry to OfflineCache
     */
    private persistRetry;
    /**
     * Remove a persisted retry from OfflineCache
     */
    private removePersistedRetry;
    /**
     * Restore scheduled retries from OfflineCache on startup
     */
    private restoreScheduledRetries;
}
/** Singleton instance */
export declare const scheduledRetryManager: ScheduledRetryManager;