/**
 * CSV Worker Pool - Browser Implementation
 *
 * High-performance worker pool for CSV operations in the browser.
 * Offloads CPU-intensive operations to Web Workers to keep UI responsive.
 *
 * Features:
 * - Parse/Format: Basic CSV operations
 * - Session Management: Keep data in worker memory for repeated operations
 * - Data Operations: sort, filter, search, groupBy, aggregate, pagination
 * - Batch Query: Execute multiple operations in single round-trip
 * - Task prioritization and cancellation
 * - Automatic worker scaling
 *
 * @example
 * ```ts
 * // Simple parsing
 * const result = await parseWithPool(csvString, { headers: true });
 *
 * // Session-based operations for interactive data exploration
 * const session = new CsvWorkerSession();
 * await session.load(csvString, { headers: true });
 *
 * // Batch query - single round-trip for multiple operations
 * const result = await session.query({
 *   sort: { column: 'age', order: 'desc' },
 *   filter: { conditions: [{ column: 'status', operator: 'eq', value: 'active' }] },
 *   page: { page: 1, pageSize: 20 }
 * });
 *
 * session.dispose();
 * ```
 */
import type { CsvWorkerPoolOptions, CsvWorkerPoolStats, CsvTaskOptions, CsvTaskResult, SortConfig, FilterConfig, SearchConfig, GroupByConfig, AggregateConfig, PageConfig, QueryConfig, FilterResult, PageResult, GroupResult, AggregateResult, QueryResult, CsvParseOptions, CsvFormatOptions, CsvParseResult } from "./types.js";
/** Check if Web Workers are available */
export declare function hasWorkerSupport(): boolean;
declare class CsvWorkerPool {
    private readonly _options;
    private readonly _workers;
    private readonly _highQueue;
    private readonly _normalQueue;
    private readonly _lowQueue;
    private readonly _pendingTasks;
    private _nextTaskId;
    private _nextWorkerId;
    private _terminated;
    private _completedTasks;
    private _failedTasks;
    private _workerUrl;
    private readonly _useCustomUrl;
    private _initPromise;
    constructor(options?: CsvWorkerPoolOptions);
    /**
     * Create and initialize a worker pool.
     * This is the recommended way to create a pool for immediate use.
     */
    static create(options?: CsvWorkerPoolOptions): Promise<CsvWorkerPool>;
    /**
     * Ensure the pool is initialized (worker URL loaded).
     * Called automatically before first task execution.
     */
    private _ensureInitialized;
    parse(data: string, options?: CsvParseOptions & {
        sessionId?: string;
    }, taskOptions?: CsvTaskOptions): Promise<CsvTaskResult<string[][] | CsvParseResult<Record<string, string>>>>;
    format(data: any[][], options?: CsvFormatOptions, taskOptions?: CsvTaskOptions): Promise<CsvTaskResult<string>>;
    load(sessionId: string, data: any[] | any[][], headers?: string[], taskOptions?: CsvTaskOptions): Promise<CsvTaskResult<{
        rowCount: number;
        headers: string[];
    }>>;
    getData(sessionId: string, taskOptions?: CsvTaskOptions): Promise<CsvTaskResult<{
        data: Record<string, any>[];
        headers: string[];
        rowCount: number;
    }>>;
    clear(sessionId?: string, taskOptions?: CsvTaskOptions): Promise<CsvTaskResult<void>>;
    sort(sessionId: string, config: SortConfig | SortConfig[], taskOptions?: CsvTaskOptions): Promise<CsvTaskResult<{
        rowCount: number;
    }>>;
    filter(sessionId: string, config: FilterConfig, taskOptions?: CsvTaskOptions): Promise<FilterResult>;
    search(sessionId: string, config: SearchConfig, taskOptions?: CsvTaskOptions): Promise<FilterResult>;
    groupBy(sessionId: string, config: GroupByConfig, taskOptions?: CsvTaskOptions): Promise<GroupResult>;
    aggregate(sessionId: string, config: AggregateConfig[], taskOptions?: CsvTaskOptions): Promise<AggregateResult>;
    getPage(sessionId: string, config: PageConfig, taskOptions?: CsvTaskOptions): Promise<PageResult>;
    query(sessionId: string, config: QueryConfig, taskOptions?: CsvTaskOptions): Promise<QueryResult>;
    getStats(): CsvWorkerPoolStats;
    terminate(): void;
    /** Execute and unwrap result - for operations that return data with duration */
    private _unwrap;
    private _execute;
    private _cleanupTask;
    private get _pendingQueueSize();
    private _enqueueTask;
    private _dequeueTask;
    private _processQueue;
    private _createWorker;
    private _assignTask;
    private _handleWorkerMessage;
    private _handleWorkerError;
    private _releaseWorker;
    private _terminateWorker;
    private _cancelTask;
}
/**
 * High-level API for interactive CSV data exploration.
 *
 * Keeps data in worker memory for efficient repeated operations.
 *
 * @example
 * ```ts
 * const session = await CsvWorkerSession.create();
 *
 * // Load data
 * await session.load(csvString, { headers: true });
 *
 * // Batch query - most efficient for multiple operations
 * const result = await session.query({
 *   sort: { column: 'age', order: 'desc' },
 *   filter: { conditions: [{ column: 'status', operator: 'eq', value: 'active' }] },
 *   page: { page: 1, pageSize: 50 }
 * });
 *
 * // Or use individual operations
 * await session.sort({ column: 'name', order: 'asc' });
 * const filtered = await session.filter({
 *   conditions: [{ column: 'age', operator: 'gt', value: 30 }]
 * });
 *
 * // Cleanup
 * session.dispose();
 * ```
 */
export declare class CsvWorkerSession {
    private readonly _pool;
    private readonly _sessionId;
    private _disposed;
    private _headers;
    private _rowCount;
    /** Use CsvWorkerSession.create() instead for lazy pool initialization */
    constructor(pool: CsvWorkerPool);
    /** Create a new session with optional pool */
    static create(pool?: CsvWorkerPool): Promise<CsvWorkerSession>;
    get sessionId(): string;
    get headers(): string[];
    get rowCount(): number;
    /**
     * Load CSV string or data into session
     */
    load(csvOrData: string | any[] | any[][], options?: CsvParseOptions & {
        headers?: string[] | boolean;
    }): Promise<{
        rowCount: number;
        headers: string[];
    }>;
    /** Get all data */
    getData: () => Promise<{
        data: Record<string, any>[];
        headers: string[];
        rowCount: number;
    }>;
    /** Sort data in place */
    sort: (config: SortConfig | SortConfig[]) => Promise<{
        rowCount: number;
    }>;
    /** Filter data (resets to original data before filtering) */
    filter: (config: FilterConfig) => Promise<FilterResult<Record<string, any>>>;
    /** Search across columns */
    search: (config: SearchConfig) => Promise<FilterResult<Record<string, any>>>;
    /** Group by and aggregate */
    groupBy: (config: GroupByConfig) => Promise<GroupResult<Record<string, any>>>;
    /** Aggregate entire dataset */
    aggregate: (config: AggregateConfig[]) => Promise<AggregateResult>;
    /** Get paginated data */
    getPage: (config: PageConfig) => Promise<PageResult<Record<string, any>>>;
    /**
     * Execute batch query - multiple operations in single round-trip
     * Order of operations: sort -> filter -> search -> groupBy/aggregate -> page
     */
    query: (config: QueryConfig) => Promise<QueryResult<Record<string, any>>>;
    /** Dispose session and free worker memory */
    dispose(): Promise<void>;
    /** Wrap operation with disposed check */
    private _wrap;
}
/** Get or create the default worker pool (with lazy initialization) */
export declare function getDefaultWorkerPool(): Promise<CsvWorkerPool>;
export declare function terminateDefaultWorkerPool(): void;
/** Parse CSV using worker pool */
export declare function parseWithPool(data: string, options?: CsvParseOptions, taskOptions?: CsvTaskOptions): Promise<CsvTaskResult<string[][] | CsvParseResult<Record<string, string>>>>;
/** Format data to CSV using worker pool */
export declare function formatWithPool(data: any[][], options?: CsvFormatOptions, taskOptions?: CsvTaskOptions): Promise<CsvTaskResult<string>>;
export { CsvWorkerPool };
export type { CsvWorkerPoolOptions, CsvWorkerPoolStats, CsvTaskOptions, CsvTaskResult, CsvTaskPriority, SortConfig, SortOrder, FilterConfig, FilterCondition, FilterOperator, SearchConfig, GroupByConfig, AggregateConfig, AggregateFunction, PageConfig, QueryConfig, FilterResult, PageResult, GroupResult, AggregateResult, QueryResult } from "./types.js";