import { EventEmitter } from 'events';
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;
    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;
    };
}
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;
}
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;
    constructor(options?: EventDrivenQueueOptions);
    private setupEventListeners;
    addUrls(urls: string[]): void;
    getNextUrl(): QueuedUrl | null;
    markCompleted(url: string, result: any): void;
    markFailed(url: string, error: string): void;
    private checkQueueEmpty;
    private updateProgress;
    getStats(): QueueStats;
    private calculatePriority;
    /**
     * 🚀 Integrierte Parallel-Verarbeitung der Queue
     * Verarbeitet alle URLs parallel mit automatischer Status-Berichterstattung
     */
    processUrls(urls: string[], options: ProcessOptions): Promise<any[]>;
    /**
     * 🔧 Worker-Funktion für parallele Verarbeitung
     */
    private worker;
    /**
     * 📊 Startet kurze Status-Updates
     */
    private startStatusUpdates;
    /**
     * ⏹️ Stoppt Status-Updates
     */
    private stopStatusUpdates;
    /**
     * 📝 Generiert kurze Status-Nachricht mit verbesserter ETA
     */
    private generateShortStatus;
    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;
    getCompletedResults(): any[];
    getFailedResults(): any[];
    clear(): void;
    pause(): void;
    resume(): void;
    isPaused(): boolean;
    getQueueSize(): number;
    getActiveWorkers(): number;
    getMaxConcurrent(): number;
    setMaxConcurrent(max: number): void;
}
//# sourceMappingURL=event-driven-queue.d.ts.map