import { EventEmitter } from '../core/EventEmitter';
/**
 * Print job status
 */
export declare enum PrintJobStatus {
    PENDING = "pending",
    IN_PROGRESS = "in_progress",
    COMPLETED = "completed",
    FAILED = "failed",
    CANCELLED = "cancelled",
    PAUSED = "paused"
}
/**
 * Print job priority
 */
export declare enum PrintJobPriority {
    LOW = 0,
    NORMAL = 1,
    HIGH = 2,
    URGENT = 3
}
/**
 * Print job
 */
export interface PrintJob {
    /** Unique job identifier */
    id: string;
    /** Print data */
    data: Uint8Array;
    /** Job status */
    status: PrintJobStatus;
    /** Job priority */
    priority: PrintJobPriority;
    /** Creation timestamp */
    createdAt: number;
    /** Start timestamp */
    startedAt?: number;
    /** Completion timestamp */
    completedAt?: number;
    /** Retry count */
    retryCount: number;
    /** Maximum retries */
    maxRetries: number;
    /** Error if failed */
    error?: Error;
    /** Additional metadata */
    metadata?: Record<string, unknown>;
}
/**
 * Queue configuration
 */
export interface QueueConfig {
    /** Maximum queue size (default: 100) */
    maxSize: number;
    /** Default retry count (default: 3) */
    defaultRetries: number;
    /** Retry delay in ms (default: 1000) */
    retryDelay: number;
    /** Auto-process queue (default: true) */
    autoProcess: boolean;
    /** Concurrent jobs (default: 1) */
    concurrency: number;
}
/**
 * Print queue events
 */
export interface PrintQueueEvents {
    'job-added': PrintJob;
    'job-started': PrintJob;
    'job-completed': PrintJob;
    'job-failed': PrintJob;
    'job-cancelled': PrintJob;
    'queue-empty': void;
    'queue-paused': void;
    'queue-resumed': void;
}
/**
 * Print queue interface
 */
export interface IPrintQueue {
    add(data: Uint8Array, options?: Partial<PrintJob>): string;
    getJob(jobId: string): PrintJob | null;
    cancel(jobId: string): boolean;
    pause(): void;
    resume(): void;
    clear(): void;
    getQueueStatus(): {
        pending: number;
        inProgress: number;
        completed: number;
        failed: number;
    };
    on<K extends keyof PrintQueueEvents>(event: K, callback: (data: PrintQueueEvents[K]) => void): void;
}
/**
 * Job execution function type
 */
export type JobExecutor = (job: PrintJob) => Promise<void>;
/**
 * Print Queue class
 * Manages print jobs with priority and retry support
 */
export declare class PrintQueue extends EventEmitter<PrintQueueEvents> implements IPrintQueue {
    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;
    };
    private readonly config;
    private jobs;
    private pendingQueue;
    private isPaused;
    private isProcessing;
    private activeJobs;
    private jobCounter;
    private executor;
    private retryQueue;
    private retryTimer;
    /**
     * Creates a new PrintQueue instance
     */
    constructor(config?: Partial<QueueConfig>);
    /**
     * Set the job executor function
     */
    setExecutor(executor: JobExecutor): void;
    /**
     * Add a job to the queue
     */
    add(data: Uint8Array, options?: Partial<PrintJob>): string;
    /**
     * Get a job by ID
     */
    getJob(jobId: string): PrintJob | null;
    /**
     * Cancel a job
     */
    cancel(jobId: string): boolean;
    /**
     * Pause the queue
     */
    pause(): void;
    /**
     * Resume the queue
     */
    resume(): void;
    /**
     * Clear all pending jobs
     */
    clear(): void;
    /**
     * Get queue status
     */
    getQueueStatus(): {
        pending: number;
        inProgress: number;
        completed: number;
        failed: number;
    };
    /**
     * Get all jobs
     */
    getAllJobs(): PrintJob[];
    /**
     * Get pending jobs in order
     */
    getPendingJobs(): PrintJob[];
    /**
     * Check if queue is paused
     */
    get paused(): boolean;
    /**
     * Get queue size
     */
    get size(): number;
    /**
     * Process the queue
     */
    private processQueue;
    /**
     * Execute a single job
     */
    private executeJob;
    /**
     * Insert job ID into pending queue by priority
     */
    private insertByPriority;
    /**
     * Remove job from pending queue
     */
    private removeFromPendingQueue;
    /**
     * Generate unique job ID
     */
    private generateJobId;
    /**
     * Schedule a job retry after the specified delay.
     * 优化：使用单个定时器 + 延迟队列，避免每个失败任务创建独立 setTimeout
     *
     * @param jobId - Job to retry
     * @param delay - Delay in milliseconds
     */
    private scheduleRetry;
    /**
     * Remove a job from the retry queue.
     */
    private removeFromRetryQueue;
    /**
     * Schedule the next retry timer.
     * 使用单个定时器触发所有到期的重试任务。
     */
    private scheduleNextRetry;
    /**
     * Process all expired retry tasks.
     */
    private processRetryQueue;
    /**
     * Clear retry timer for a specific job.
     * 优化：从延迟队列中移除，不再需要 clearTimeout
     */
    private clearRetryTimer;
    /**
     * Clear all retry timers.
     * 优化：清空队列并清除单个定时器
     */
    private clearAllRetryTimers;
}
export declare const printQueue: PrintQueue;