import { EventDrivenQueueOptions, QueueStats } from './event-driven-queue';
import { AccessibilityChecker } from '../accessibility';
import { TestOptions, AccessibilityResult } from '../types';
/**
 * @deprecated ParallelTestManagerOptions is deprecated and will be removed in v3.0.0
 * Use AccessibilityChecker with unified event system instead
 */
export interface ParallelTestManagerOptions extends EventDrivenQueueOptions {
    maxConcurrent?: number;
    maxRetries?: number;
    retryDelay?: number;
    testOptions?: TestOptions;
    accessibilityChecker?: AccessibilityChecker;
    verbose?: boolean;
    enableResourceMonitoring?: boolean;
    maxMemoryUsage?: number;
    maxCpuUsage?: number;
    enablePersistence?: boolean;
    stateAdapter?: any;
    autoSave?: boolean;
    autoSaveInterval?: number;
    stateId?: string;
    resumable?: boolean;
    onTestStart?: (url: string) => void;
    onTestComplete?: (url: string, result: AccessibilityResult) => void;
    onTestError?: (url: string, error: string) => void;
    onProgressUpdate?: (stats: QueueStats) => void;
    onQueueEmpty?: () => void;
}
export interface ParallelTestResult {
    results: AccessibilityResult[];
    stats: QueueStats;
    duration: number;
    errors: Array<{
        url: string;
        error: string;
        attempts: number;
    }>;
}
/**
 * @deprecated ParallelTestManager is deprecated and will be removed in v3.0.0
 *
 * This class is replaced by the unified PageAnalysisEmitter system integrated into AccessibilityChecker.
 * The new system provides better performance, consistent event handling, and integrated resource monitoring.
 *
 * MIGRATION GUIDE:
 * ```typescript
 * // OLD (deprecated)
 * const manager = new ParallelTestManager({
 *   maxConcurrent: 3,
 *   onTestComplete: (url, result) => { ... }
 * });
 * await manager.runTests(urls);
 *
 * // NEW (recommended)
 * const checker = new AccessibilityChecker({
 *   enableUnifiedEvents: true,
 *   enableComprehensiveAnalysis: true
 * });
 * checker.setUnifiedEventCallbacks({ onUrlCompleted: (url, result) => { ... } });
 * await checker.testMultiplePagesParallel(urls, { maxConcurrent: 3 });
 * ```
 */
export declare class ParallelTestManager {
    private queue;
    private accessibilityChecker;
    private options;
    private isRunning;
    private startTime;
    private activeTests;
    constructor(options?: ParallelTestManagerOptions);
    initialize(): Promise<void>;
    /**
     * Resume tests from saved state
     */
    resumeFromState(stateId?: string): Promise<void>;
    /**
     * Get the current state ID
     */
    getStateId(): string;
    /**
     * Save current state
     */
    saveState(): Promise<void>;
    runTests(urls: string[]): Promise<ParallelTestResult>;
    private processQueue;
    private startWorkers;
    private processNextUrl;
    private checkResourceLimits;
    private handleUrlAdded;
    private handleUrlStarted;
    private handleUrlCompleted;
    private handleUrlFailed;
    private handleUrlRetrying;
    private handleQueueEmpty;
    private handleProgressUpdate;
    private handleError;
    private setupEventListeners;
    pause(): void;
    resume(): void;
    stop(): void;
    getStats(): QueueStats;
    getActiveTests(): number;
    getQueueSize(): number;
    setMaxConcurrent(max: number): void;
    getMemoryUsage(): number;
    getCpuUsage(): number;
    cleanup(): Promise<void>;
}
//# sourceMappingURL=parallel-test-manager.d.ts.map