import { WorkerPool } from '../../core/types';
/**
 * Options for creating a WorkerSession.
 */
export interface WorkerSessionOptions {
    /**
     * Custom worker URL.
     */
    workerURL?: string | URL | undefined;
    /**
     * Worker pool for reusable workers.
     */
    workerPool?: WorkerPool | undefined;
}
/**
 * WorkerSession manages the lifecycle of a single worker instance.
 *
 * Hybrid approach:
 * - If workerPool is provided: Use pool's worker (reusable, manual pool cleanup)
 * - If workerPool is NOT provided: Create disposable worker (auto-cleanup on dispose)
 *
 * Use `using` syntax for automatic cleanup:
 * ```typescript
 * using session = await WorkerSession.create();
 * const records = await sendWorkerMessage(session, { ... });
 * // Worker is automatically terminated when leaving scope (if disposable)
 * ```
 *
 * @example Disposable worker (one-time use)
 * ```typescript
 * using session = await WorkerSession.create();
 * const records = await sendWorkerMessage(session.getWorker(), {
 *   id: session.getNextRequestId(),
 *   type: "parseString",
 *   data: csv,
 *   options: serializeOptions(options),
 * });
 * // Worker automatically terminated
 * ```
 *
 * @example With WorkerPool (reusable)
 * ```typescript
 * using pool = new WorkerPool({ maxWorkers: 3 });
 * using session = await WorkerSession.create({ workerPool: pool });
 * const records1 = await sendWorkerMessage(session.getWorker(), { ... });
 * const records2 = await sendWorkerMessage(session.getWorker(), { ... });
 * // Worker returned to pool, pool cleanup happens when pool disposes
 * ```
 */
export declare class WorkerSession implements Disposable {
    private worker;
    private requestIdCounter;
    private readonly workerPool?;
    private constructor();
    /**
     * Create a new WorkerSession.
     *
     * @param options Session options
     * @returns Promise that resolves to a WorkerSession instance
     */
    static create(options?: WorkerSessionOptions): Promise<WorkerSession>;
    /**
     * Get the worker instance.
     */
    getWorker(): Worker;
    /**
     * Get the next request ID for this session.
     * - If using WorkerPool: Delegates to pool's getNextRequestId()
     * - If disposable: Uses internal counter
     */
    getNextRequestId(): number;
    /**
     * Dispose the session.
     * - If using a pool: Releases the worker back to the pool (behavior depends on pool type)
     * - If disposable: Terminates the worker
     */
    [Symbol.dispose](): void;
}