/**
 * @file Worker Utilities
 * @description Web Worker management utilities including worker pooling,
 * task distribution, and typed worker communication
 */
/**
 * Worker message types
 */
export interface WorkerMessage<T = unknown> {
    id: string;
    type: string;
    payload: T;
    timestamp: number;
}
/**
 * Worker response types
 */
export interface WorkerResponse<T = unknown> {
    id: string;
    type: 'success' | 'error' | 'progress';
    payload: T;
    error?: string;
    progress?: number;
    timestamp: number;
}
/**
 * Worker task definition
 */
export interface WorkerTask<TInput = unknown, TOutput = unknown> {
    id: string;
    type: string;
    input: TInput;
    priority?: number;
    timeout?: number;
    transferables?: Transferable[];
    onProgress?: (progress: number) => void;
    resolve: (value: TOutput) => void;
    reject: (error: Error) => void;
}
/**
 * Worker pool configuration
 */
export interface WorkerPoolConfig {
    /** Maximum number of workers in pool */
    maxWorkers?: number;
    /** Idle timeout before terminating worker (ms) */
    idleTimeout?: number;
    /** Task timeout (ms) */
    taskTimeout?: number;
    /** Enable warm-up workers on creation */
    warmUp?: boolean;
}
/**
 * Worker status
 */
export type WorkerStatus = 'idle' | 'busy' | 'terminated';
/**
 * Worker info
 */
export interface WorkerInfo {
    id: string;
    status: WorkerStatus;
    currentTask: string | null;
    tasksCompleted: number;
    errorCount: number;
    createdAt: number;
    lastActiveAt: number;
}
/**
 * Type-safe worker wrapper with promise-based communication
 */
export declare class TypedWorker<TInput, TOutput> {
    private worker;
    private pendingTasks;
    private progressCallbacks;
    private messageCounter;
    private terminated;
    constructor(workerUrl: string | URL, options?: WorkerOptions);
    /**
     * Post task to worker
     */
    postTask(type: string, payload: TInput, options?: {
        timeout?: number;
        transferables?: Transferable[];
        onProgress?: (progress: number) => void;
    }): Promise<TOutput>;
    /**
     * Terminate worker
     */
    terminate(): void;
    /**
     * Check if worker is terminated
     */
    isTerminated(): boolean;
    /**
     * Get pending task count
     */
    getPendingCount(): number;
    /**
     * Setup message listeners
     */
    private setupListeners;
}
/**
 * Worker pool for distributing tasks across multiple workers
 */
export declare class WorkerPool<TInput = unknown, TOutput = unknown> {
    private config;
    private readonly workerUrl;
    private readonly workerOptions;
    private workers;
    private taskQueue;
    private pendingResponses;
    private progressCallbacks;
    private workerCounter;
    private disposed;
    constructor(workerUrl: string | URL, config?: WorkerPoolConfig, workerOptions?: WorkerOptions);
    /**
     * Execute a task
     */
    execute(type: string, input: TInput, options?: {
        priority?: number;
        timeout?: number;
        transferables?: Transferable[];
        onProgress?: (progress: number) => void;
    }): Promise<TOutput>;
    /**
     * Get pool statistics
     */
    getStats(): {
        totalWorkers: number;
        idleWorkers: number;
        busyWorkers: number;
        queuedTasks: number;
        totalTasksCompleted: number;
        totalErrors: number;
    };
    /**
     * Get worker info
     */
    getWorkerInfo(): WorkerInfo[];
    /**
     * Resize pool
     */
    resize(maxWorkers: number): void;
    /**
     * Dispose pool
     */
    dispose(): void;
    /**
     * Warm up pool by creating minimum workers
     */
    private warmUp;
    /**
     * Create a new worker
     */
    private createWorker;
    /**
     * Setup worker event listeners
     */
    private setupWorkerListeners;
    /**
     * Schedule idle timeout for worker
     */
    private scheduleIdleTimeout;
    /**
     * Get an available worker
     */
    private getAvailableWorker;
    /**
     * Process task queue
     */
    private processQueue;
    /**
     * Terminate a specific worker
     */
    private terminateWorker;
}
/**
 * Create an inline worker from a function
 */
export declare function createInlineWorker<TInput, TOutput>(handler: (message: WorkerMessage<TInput>) => TOutput | Promise<TOutput>): TypedWorker<TInput, TOutput>;
/**
 * Check if value is transferable
 */
export declare function isTransferable(value: unknown): value is Transferable;
/**
 * Extract transferables from an object
 */
export declare function extractTransferables(obj: unknown): Transferable[];
/**
 * Shared worker wrapper
 */
export declare class TypedSharedWorker<TInput, TOutput> {
    private readonly worker;
    private pendingTasks;
    private messageCounter;
    constructor(workerUrl: string | URL);
    /**
     * Check if shared worker is supported
     */
    isSupported(): boolean;
    /**
     * Post task
     */
    postTask(type: string, payload: TInput): Promise<TOutput>;
    /**
     * Setup listeners
     */
    private setupListeners;
}
/**
 * Registry for managing multiple worker pools
 */
declare class WorkerRegistry {
    private pools;
    /**
     * Register a worker pool
     */
    register<TInput, TOutput>(name: string, workerUrl: string | URL, config?: WorkerPoolConfig): WorkerPool<TInput, TOutput>;
    /**
     * Get a worker pool
     */
    get<TInput, TOutput>(name: string): WorkerPool<TInput, TOutput> | undefined;
    /**
     * Unregister a worker pool
     */
    unregister(name: string): void;
    /**
     * Dispose all pools
     */
    disposeAll(): void;
    /**
     * Get all pool stats
     */
    getAllStats(): Record<string, ReturnType<WorkerPool['getStats']>>;
}
/**
 * Global worker registry
 */
export declare const workerRegistry: WorkerRegistry;
export {};