import { EventEmitter } from 'events';
import { BackpressureConfig } from '../backpressure-controller';
import { ResourceMonitorConfig } from '../resource-monitor';
import { QueueStateAdapter, ResumeOptions } from '../../types/queue-state';
/**
 * @deprecated EventDrivenQueue is deprecated and will be removed in v3.0.0
 * Use PageAnalysisEmitter instead for unified event handling across all analyzers
 *
 * Migration Guide:
 * - Replace EventDrivenQueue with PageAnalysisEmitter
 * - Use UnifiedEventCallbacks instead of EventDrivenQueueOptions.eventCallbacks
 * - Access via AccessibilityChecker.getUnifiedEmitter() for advanced usage
 */
export interface QueuedUrl {
    url: string;
    priority: number;
    status: 'pending' | 'in-progress' | 'completed' | 'failed' | 'retrying';
    attempts: number;
    result?: any;
    error?: string;
    startedAt?: Date;
    completedAt?: Date;
    duration?: number;
}
export interface QueueEvent {
    type: 'url-added' | 'url-started' | 'url-completed' | 'url-failed' | 'url-retrying' | 'queue-empty' | 'progress-update' | 'error';
    data: any;
    timestamp: Date;
}
export interface EventDrivenQueueOptions {
    maxRetries?: number;
    maxConcurrent?: number;
    priorityPatterns?: Array<{
        pattern: string;
        priority: number;
    }>;
    retryDelay?: number;
    enableEvents?: boolean;
    enableShortStatus?: boolean;
    statusUpdateInterval?: number;
    enableBackpressure?: boolean;
    backpressureConfig?: Partial<BackpressureConfig>;
    enableResourceMonitoring?: boolean;
    resourceMonitorConfig?: Partial<ResourceMonitorConfig>;
    hardTimeout?: number;
    globalTimeout?: number;
    enablePersistence?: boolean;
    stateAdapter?: QueueStateAdapter;
    autoSave?: boolean;
    autoSaveInterval?: number;
    stateId?: string;
    resumable?: boolean;
    eventCallbacks?: {
        onUrlAdded?: (url: string, priority: number) => void;
        onUrlStarted?: (url: string) => void;
        onUrlCompleted?: (url: string, result: any, duration: number) => void;
        onUrlFailed?: (url: string, error: string, attempts: number) => void;
        onUrlRetrying?: (url: string, attempts: number) => void;
        onQueueEmpty?: () => void;
        onProgressUpdate?: (stats: QueueStats) => void;
        onError?: (error: string) => void;
        onShortStatus?: (status: string) => void;
        onBackpressureActivated?: (reason: string) => void;
        onBackpressureDeactivated?: () => void;
        onResourceWarning?: (usage: number, limit: number) => void;
        onResourceCritical?: (usage: number, limit: number) => void;
        onGarbageCollection?: (beforeMB: number, afterMB?: number) => void;
    };
}
export interface QueueStats {
    total: number;
    pending: number;
    inProgress: number;
    completed: number;
    failed: number;
    retrying: number;
    progress: number;
    averageDuration: number;
    estimatedTimeRemaining: number;
    activeWorkers: number;
    memoryUsage: number;
    cpuUsage: number;
}
export interface ProcessOptions {
    processor: (url: string) => Promise<any>;
    onResult?: (url: string, result: any) => void;
    onError?: (url: string, error: string) => void;
    onProgress?: (stats: QueueStats) => void;
    onShortStatus?: (status: string) => void;
}
/**
 * @deprecated EventDrivenQueue class is deprecated and will be removed in v3.0.0
 *
 * Use PageAnalysisEmitter for unified event handling instead.
 * This class is maintained for backward compatibility only.
 *
 * MIGRATION PATH:
 * ```typescript
 * // OLD (deprecated)
 * const queue = new EventDrivenQueue({ eventCallbacks: { ... } });
 *
 * // NEW (recommended)
 * const emitter = new PageAnalysisEmitter({ callbacks: { ... } });
 * // OR via AccessibilityChecker
 * const checker = new AccessibilityChecker({ enableUnifiedEvents: true });
 * checker.setUnifiedEventCallbacks({ ... });
 * ```
 */
export declare class EventDrivenQueue extends EventEmitter {
    private queue;
    private completed;
    private failed;
    private activeWorkers;
    private options;
    private isProcessing;
    private startTime;
    private lastProgressUpdate;
    private progressUpdateInterval;
    private statusInterval;
    private backpressureController?;
    private resourceMonitor?;
    private hardTimeoutTracker;
    private globalTimeoutTimer;
    private stateAdapter?;
    private autoSaveTimer;
    private stateId;
    private currentState;
    constructor(options?: EventDrivenQueueOptions);
    /**
     * Setup backpressure controller
     */
    private setupBackpressure;
    /**
     * Setup persistence functionality
     */
    private setupPersistence;
    /**
     * Generate unique state ID based on timestamp and random string
     */
    private generateStateId;
    /**
     * Setup resource monitoring
     */
    private setupResourceMonitoring;
    private setupEventListeners;
    addUrls(urls: string[]): void;
    getNextUrl(): Promise<QueuedUrl | null>;
    markCompleted(url: string, result: any): void;
    markFailed(url: string, error: string): void;
    /**
     * Update backpressure controller with current state
     */
    private updateBackpressure;
    private checkQueueEmpty;
    private updateProgress;
    getStats(): QueueStats;
    private calculatePriority;
    /**
     * Start auto-save timer
     */
    private startAutoSave;
    /**
     * Stop auto-save timer
     */
    private stopAutoSave;
    /**
     * Create current queue state snapshot
     */
    private createStateSnapshot;
    /**
     * Save current state to adapter
     */
    saveState(): Promise<void>;
    /**
     * Load state from adapter and resume processing
     */
    resumeFromState(options?: ResumeOptions): Promise<void>;
    /**
     * Delete saved state
     */
    deleteState(stateId?: string): Promise<void>;
    /**
     * List all available saved states
     */
    listSavedStates(): Promise<string[]>;
    /**
     * Get state ID
     */
    getStateId(): string;
    /**
     * Check if persistence is enabled
     */
    isPersistenceEnabled(): boolean;
    /**
     * 🚀 Integrated parallel queue processing
     * Processes all URLs in parallel with automatic status reporting
     */
    processUrls(urls: string[], options: ProcessOptions): Promise<any[]>;
    /**
     * 🔧 Worker function for parallel processing (optimized to prevent timeout accumulation)
     */
    private worker;
    /**
     * 📊 Starts short status updates
     */
    private startStatusUpdates;
    /**
     * ⏹️ Stops status updates
     */
    private stopStatusUpdates;
    /**
     * 📝 Generates short status message with improved ETA
     */
    private generateShortStatus;
    /**
     * Create a simple progress bar
     */
    private createProgressBar;
    onUrlAdded(callback: (event: QueueEvent) => void): this;
    onUrlStarted(callback: (event: QueueEvent) => void): this;
    onUrlCompleted(callback: (event: QueueEvent) => void): this;
    onUrlFailed(callback: (event: QueueEvent) => void): this;
    onUrlRetrying(callback: (event: QueueEvent) => void): this;
    onQueueEmpty(callback: (event: QueueEvent) => void): this;
    onProgressUpdate(callback: (event: QueueEvent) => void): this;
    onError(callback: (event: QueueEvent) => void): this;
    /**
     * Cleanup resources and stop processing
     */
    destroy(): void;
    /**
     * Force garbage collection if available
     */
    forceGarbageCollection(): boolean;
    getCompletedResults(): any[];
    getFailedResults(): any[];
    clear(): void;
    pause(): void;
    resume(): void;
    isPaused(): boolean;
    /**
     * 🧯 Cleanup method to prevent memory leaks
     */
    cleanup(): void;
    getQueueSize(): number;
    getActiveWorkers(): number;
    getMaxConcurrent(): number;
    setMaxConcurrent(max: number): void;
}
//# sourceMappingURL=event-driven-queue.d.ts.map