/**
 * Browser Worker Pool Implementation
 *
 * A worker pool for parallel compression/decompression in the browser.
 * Automatically manages worker lifecycle, task scheduling, and load balancing.
 *
 * Features:
 * - Automatic worker scaling based on workload
 * - Task prioritization (high/normal/low)
 * - Idle worker termination to save resources
 * - Transferable objects for zero-copy data transfer
 * - Task cancellation via AbortSignal
 * - Graceful error handling and recovery
 */
import { hasWorkerSupport } from "./pool.base.js";
import type { WorkerPoolOptions, WorkerPoolStats, TaskOptions, TaskResult, WorkerTaskType } from "./types.js";
export type { WorkerPoolOptions, WorkerPoolStats, TaskOptions, TaskResult, WorkerTaskType };
export { hasWorkerSupport };
export interface WorkerPoolStream {
    write(data: Uint8Array): Promise<void>;
    end(): Promise<void>;
    abort(reason?: string): void;
}
/**
 * Browser Worker Pool
 *
 * Manages a pool of Web Workers for parallel compression/decompression.
 */
export declare class WorkerPool {
    private readonly _options;
    private readonly _workers;
    private readonly _taskQueue;
    private _taskQueueHead;
    private readonly _pendingTasks;
    private _nextTaskId;
    private _nextWorkerId;
    private _terminated;
    private _completedTasks;
    private _failedTasks;
    private readonly _workerUrl;
    private readonly _useCustomUrl;
    private readonly _pendingStreamRequests;
    private _pendingStreamRequestHead;
    private _taskQueueSize;
    private _compactTaskQueueIfNeeded;
    private _dequeueTask;
    private _compactPendingStreamRequestsIfNeeded;
    private _dequeuePendingStreamRequest;
    private _waitForStreamSlot;
    private _waitForStreamDrain;
    private _resolveSlotWaiter;
    private _resolveDrainWaiter;
    constructor(options?: WorkerPoolOptions);
    /**
     * Execute a task in the worker pool
     */
    execute(taskType: WorkerTaskType, data: Uint8Array, options?: TaskOptions & {
        level?: number;
    }): Promise<TaskResult>;
    /**
     * Get current pool statistics
     */
    getStats(): WorkerPoolStats;
    /**
     * Terminate all workers and clean up resources
     */
    terminate(): void;
    /**
     * Check if the pool has been terminated
     */
    isTerminated(): boolean;
    /**
     * Create a new worker
     */
    private _createWorker;
    /**
     * Terminate a single worker
     */
    private _terminateWorker;
    /**
     * Clear a worker's idle timer if set
     */
    private _clearIdleTimer;
    /**
     * Find an idle worker
     */
    private _findIdleWorker;
    /**
     * Enqueue a task with priority ordering using binary search (O(log n))
     */
    private _enqueueTask;
    /**
     * Process the task queue
     */
    private _processQueue;
    /**
     * Assign a task to a worker
     */
    private _assignTask;
    /**
     * Handle message from worker
     */
    private _handleWorkerMessage;
    /**
     * Handle worker error
     */
    private _handleWorkerError;
    /**
     * Called when a worker becomes idle
     */
    private _workerBecameIdle;
    /**
     * Open a streaming session bound to a worker.
     *
     * This enables true chunk-by-chunk compression/decompression in the worker without buffering
     * the entire input on the main thread.
     */
    openStream(taskType: WorkerTaskType, options?: {
        level?: number;
        allowTransfer?: boolean;
        onData: (chunk: Uint8Array) => void;
        onEnd: () => void;
        onError: (err: Error) => void;
    }): WorkerPoolStream;
    private _bindStreamSession;
    private _startStreamSession;
    /**
     * Cancel a task
     */
    private _cancelTask;
    /**
     * Clean up task resources
     */
    private _cleanupTask;
    /**
     * Execute multiple tasks in parallel
     *
     * @param tasks - Array of task definitions
     * @returns Array of results in the same order as input
     */
    executeBatch(tasks: Array<{
        taskType: WorkerTaskType;
        data: Uint8Array;
        options?: TaskOptions & {
            level?: number;
        };
    }>): Promise<TaskResult[]>;
}
/**
 * Get or create the default worker pool
 */
export declare function getDefaultWorkerPool(options?: WorkerPoolOptions): WorkerPool;
/**
 * Terminate the default worker pool
 */
export declare function terminateDefaultWorkerPool(): void;
/**
 * Execute a compression task using the default pool
 */
export declare function deflateWithPool(data: Uint8Array, options?: TaskOptions & {
    level?: number;
}): Promise<Uint8Array>;
/**
 * Execute a decompression task using the default pool
 */
export declare function inflateWithPool(data: Uint8Array, options?: TaskOptions): Promise<Uint8Array>;
/**
 * Batch compress multiple data chunks in parallel using the default pool
 */
export declare function deflateBatchWithPool(items: Array<{
    data: Uint8Array;
    options?: TaskOptions & {
        level?: number;
    };
}>): Promise<Uint8Array[]>;
/**
 * Batch decompress multiple data chunks in parallel using the default pool
 */
export declare function inflateBatchWithPool(items: Array<{
    data: Uint8Array;
    options?: TaskOptions;
}>): Promise<Uint8Array[]>;