@cj-tech-master/excelts 5.1.18 → 6.0.0-beta.1

package/dist/browser/modules/csv/utils/number.d.ts

@@ -0,0 +1,36 @@
+/**
+ * CSV Number Utilities
+ *
+ * Functions for parsing and formatting numbers in CSV files,
+ * with support for different decimal separators (e.g., European format).
+ */
+/**
+ * Decimal separator type.
+ * - "." - Standard decimal point (default)
+ * - "," - European decimal comma
+ */
+export type DecimalSeparator = "." | ",";
+/**
+ * Format a number for CSV output with the specified decimal separator.
+ *
+ * @param value - The number to format
+ * @param decimalSeparator - The decimal separator to use
+ * @returns Formatted string representation
+ *
+ * @example
+ * formatNumberForCsv(3.14, ".") // "3.14"
+ * formatNumberForCsv(3.14, ",") // "3,14"
+ */
+export declare function formatNumberForCsv(value: number, decimalSeparator: DecimalSeparator): string;
+/**
+ * Parse a CSV string value as a number with the specified decimal separator.
+ *
+ * @param value - The string value to parse
+ * @param decimalSeparator - The decimal separator used in the value
+ * @returns Parsed number (may be NaN if invalid)
+ *
+ * @example
+ * parseNumberFromCsv("3.14", ".") // 3.14
+ * parseNumberFromCsv("3,14", ",") // 3.14
+ */
+export declare function parseNumberFromCsv(value: string, decimalSeparator: DecimalSeparator): number;

package/dist/browser/modules/csv/utils/number.js

@@ -0,0 +1,49 @@
+/**
+ * CSV Number Utilities
+ *
+ * Functions for parsing and formatting numbers in CSV files,
+ * with support for different decimal separators (e.g., European format).
+ */
+/** Pre-compiled regex for European decimal comma format */
+const COMMA_DECIMAL_REGEX = /^-?\d+(,\d+)?([eE][+-]?\d+)?$/;
+/**
+ * Format a number for CSV output with the specified decimal separator.
+ *
+ * @param value - The number to format
+ * @param decimalSeparator - The decimal separator to use
+ * @returns Formatted string representation
+ *
+ * @example
+ * formatNumberForCsv(3.14, ".") // "3.14"
+ * formatNumberForCsv(3.14, ",") // "3,14"
+ */
+export function formatNumberForCsv(value, decimalSeparator) {
+    if (decimalSeparator !== ",") {
+        return String(value);
+    }
+    // Replace decimal point with comma - faster than split().join()
+    return String(value).replace(".", ",");
+}
+/**
+ * Parse a CSV string value as a number with the specified decimal separator.
+ *
+ * @param value - The string value to parse
+ * @param decimalSeparator - The decimal separator used in the value
+ * @returns Parsed number (may be NaN if invalid)
+ *
+ * @example
+ * parseNumberFromCsv("3.14", ".") // 3.14
+ * parseNumberFromCsv("3,14", ",") // 3.14
+ */
+export function parseNumberFromCsv(value, decimalSeparator) {
+    const trimmed = value.trim();
+    if (decimalSeparator !== ",") {
+        return Number(trimmed);
+    }
+    // Minimal locale support: treat a single comma as the decimal separator.
+    // Common EU CSV uses delimiter ';' and decimal ',' (e.g. 12,34).
+    if (COMMA_DECIMAL_REGEX.test(trimmed)) {
+        return Number(trimmed.replace(",", "."));
+    }
+    return Number(trimmed);
+}

package/dist/browser/modules/csv/utils/row.d.ts

@@ -0,0 +1,111 @@
+/**
+ * CSV Row Utilities
+ *
+ * Helper functions for working with different row formats:
+ * - RowHashArray: Array of [key, value] tuples, e.g., [["name", "John"], ["age", "30"]]
+ * - RowMap: Record<string, any> object format
+ * - RowArray: Simple string[] array format
+ *
+ * Key functions:
+ * - isRowHashArray(): Type guard for RowHashArray detection
+ * - extractRowValues(): Extract values from any row format
+ * - detectRowKeys(): Detect header keys from a row
+ * - deduplicateHeaders(): Handle duplicate column names
+ * - processColumns(): Process column configuration
+ */
+import type { ColumnConfig, HeaderArray, RowHashArray } from "../types.js";
+export type { HeaderArray, RowHashArray } from "../types.js";
+/**
+ * Check if a row is a RowHashArray (array of [key, value] tuples)
+ */
+export declare function isRowHashArray(row: unknown): row is RowHashArray;
+/**
+ * Convert RowHashArray to RowMap
+ * Note: Manual loop is ~4x faster than Object.fromEntries
+ */
+export declare function rowHashArrayToMap<V = any>(row: RowHashArray<V>): Record<string, V>;
+/**
+ * Convert RowHashArray to values array (preserving order)
+ */
+export declare function rowHashArrayToValues<V = any>(row: RowHashArray<V>): V[];
+/**
+ * Get headers from RowHashArray
+ */
+export declare function rowHashArrayToHeaders(row: RowHashArray): string[];
+/**
+ * Get value by key from RowHashArray (returns undefined if not found)
+ * More efficient than creating a full map when you need only specific values
+ */
+export declare function rowHashArrayGet<V = any>(row: RowHashArray<V>, key: string): V | undefined;
+/**
+ * Map RowHashArray values according to header order
+ * Optimized: builds values array in single pass without intermediate object
+ */
+export declare function rowHashArrayMapByHeaders<V = any>(row: RowHashArray<V>, headers: string[]): (V | undefined)[];
+/**
+ * Extract values from a row (array, object, or RowHashArray) in consistent order.
+ * This is the unified function for row value extraction used by both
+ * batch (formatCsv) and streaming (CsvFormatterStream) code paths.
+ *
+ * @param row - The row data (array, object, or RowHashArray)
+ * @param keys - Optional key order for object/RowHashArray rows
+ * @returns Array of values in the specified key order (or natural order if no keys)
+ */
+export declare function extractRowValues(row: unknown, keys: string[] | null | undefined): unknown[];
+/**
+ * Auto-detect keys (headers) from a row based on its type.
+ * Returns empty array for arrays or primitive values.
+ *
+ * @param row - The row data to detect keys from
+ * @returns Array of string keys, or empty array if not applicable
+ */
+export declare function detectRowKeys(row: unknown): string[];
+/**
+ * Deduplicate headers by appending suffix to duplicates.
+ * Example: ["A", "B", "A", "A"] → ["A", "B", "A_1", "A_2"]
+ *
+ * @param headers - Original header array
+ * @returns New array with unique header names
+ */
+export declare function deduplicateHeaders(headers: HeaderArray): HeaderArray;
+export declare function deduplicateHeadersWithRenames(headers: HeaderArray): {
+    headers: HeaderArray;
+    renamedHeaders: Record<string, string> | null;
+};
+/**
+ * Process columns configuration to extract keys and headers.
+ * Returns null if columns is empty or undefined.
+ *
+ * This function is used by both formatCsv (batch) and CsvFormatterStream (streaming)
+ * to normalize column configuration into separate key/header arrays.
+ *
+ * @param columns - Column configuration array (string names or ColumnConfig objects)
+ * @returns Object with keys (data access) and headers (output names), or null if empty
+ *
+ * @example
+ * ```ts
+ * processColumns(['name', { key: 'age', header: 'Age (years)' }])
+ * // { keys: ['name', 'age'], headers: ['name', 'Age (years)'] }
+ * ```
+ */
+export declare function processColumns(columns: (string | ColumnConfig)[] | undefined): {
+    keys: string[];
+    headers: string[];
+} | null;
+/**
+ * Check if a row should be skipped as empty.
+ * When `shouldSkipEmpty` is "greedy", whitespace-only rows also count as empty.
+ *
+ * @param row - The row to check
+ * @param shouldSkipEmpty - true, false, or "greedy"
+ * @returns true if the row should be skipped
+ */
+export declare function isEmptyRow(row: string[], shouldSkipEmpty: boolean | "greedy"): boolean;
+/**
+ * Check if all values in a row are empty strings.
+ * Used by skipRecordsWithEmptyValues option.
+ *
+ * @param row - The row to check
+ * @returns true if all fields are empty strings
+ */
+export declare function hasAllEmptyValues(row: string[]): boolean;

package/dist/browser/modules/csv/utils/row.js

@@ -0,0 +1,255 @@
+/**
+ * CSV Row Utilities
+ *
+ * Helper functions for working with different row formats:
+ * - RowHashArray: Array of [key, value] tuples, e.g., [["name", "John"], ["age", "30"]]
+ * - RowMap: Record<string, any> object format
+ * - RowArray: Simple string[] array format
+ *
+ * Key functions:
+ * - isRowHashArray(): Type guard for RowHashArray detection
+ * - extractRowValues(): Extract values from any row format
+ * - detectRowKeys(): Detect header keys from a row
+ * - deduplicateHeaders(): Handle duplicate column names
+ * - processColumns(): Process column configuration
+ */
+// =============================================================================
+// RowHashArray Utilities
+// =============================================================================
+/**
+ * Check if a row is a RowHashArray (array of [key, value] tuples)
+ */
+export function isRowHashArray(row) {
+    if (!Array.isArray(row) || row.length === 0) {
+        return false;
+    }
+    // Check if first element is a 2-element array with string key
+    const first = row[0];
+    return Array.isArray(first) && first.length === 2 && typeof first[0] === "string";
+}
+/**
+ * Convert RowHashArray to RowMap
+ * Note: Manual loop is ~4x faster than Object.fromEntries
+ */
+export function rowHashArrayToMap(row) {
+    const obj = {};
+    for (const [key, value] of row) {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Convert RowHashArray to values array (preserving order)
+ */
+export function rowHashArrayToValues(row) {
+    return row.map(([, value]) => value);
+}
+/**
+ * Get headers from RowHashArray
+ */
+export function rowHashArrayToHeaders(row) {
+    return row.map(([key]) => key);
+}
+/**
+ * Get value by key from RowHashArray (returns undefined if not found)
+ * More efficient than creating a full map when you need only specific values
+ */
+export function rowHashArrayGet(row, key) {
+    for (const [k, v] of row) {
+        if (k === key) {
+            return v;
+        }
+    }
+    return undefined;
+}
+/**
+ * Map RowHashArray values according to header order
+ * Optimized: builds values array in single pass without intermediate object
+ */
+export function rowHashArrayMapByHeaders(row, headers) {
+    // For small headers array, linear search per header is faster than building a map
+    // For larger headers (>10), build a map once
+    if (headers.length <= 10) {
+        return headers.map(h => rowHashArrayGet(row, h));
+    }
+    const map = rowHashArrayToMap(row);
+    return headers.map(h => map[h]);
+}
+/**
+ * Extract values from a row (array, object, or RowHashArray) in consistent order.
+ * This is the unified function for row value extraction used by both
+ * batch (formatCsv) and streaming (CsvFormatterStream) code paths.
+ *
+ * @param row - The row data (array, object, or RowHashArray)
+ * @param keys - Optional key order for object/RowHashArray rows
+ * @returns Array of values in the specified key order (or natural order if no keys)
+ */
+export function extractRowValues(row, keys) {
+    if (isRowHashArray(row)) {
+        return keys ? rowHashArrayMapByHeaders(row, keys) : rowHashArrayToValues(row);
+    }
+    if (Array.isArray(row)) {
+        return row;
+    }
+    if (row !== null && typeof row === "object") {
+        return keys ? keys.map(key => row[key]) : Object.values(row);
+    }
+    // Primitive value: wrap in array
+    return [row];
+}
+/**
+ * Auto-detect keys (headers) from a row based on its type.
+ * Returns empty array for arrays or primitive values.
+ *
+ * @param row - The row data to detect keys from
+ * @returns Array of string keys, or empty array if not applicable
+ */
+export function detectRowKeys(row) {
+    if (isRowHashArray(row)) {
+        return rowHashArrayToHeaders(row);
+    }
+    if (!Array.isArray(row) && row !== null && typeof row === "object") {
+        return Object.keys(row);
+    }
+    return [];
+}
+// =============================================================================
+// Header Utilities
+// =============================================================================
+/**
+ * Deduplicate headers by appending suffix to duplicates.
+ * Example: ["A", "B", "A", "A"] → ["A", "B", "A_1", "A_2"]
+ *
+ * @param headers - Original header array
+ * @returns New array with unique header names
+ */
+export function deduplicateHeaders(headers) {
+    return deduplicateHeadersWithRenames(headers).headers;
+}
+export function deduplicateHeadersWithRenames(headers) {
+    const headerCount = new Map();
+    const usedHeaders = new Set();
+    // Reserve all original header names so we don't generate a rename that
+    // collides with a header that appears later in the row.
+    const reservedHeaders = new Set();
+    const result = [];
+    const renamedHeaders = {};
+    let hasRenames = false;
+    let emptyHeaderCount = 0;
+    for (const header of headers) {
+        if (header !== null && header !== undefined && header !== "") {
+            reservedHeaders.add(header);
+        }
+    }
+    for (let i = 0; i < headers.length; i++) {
+        const header = headers[i];
+        if (header === null || header === undefined) {
+            result.push(header);
+            continue;
+        }
+        // Handle empty string headers by generating placeholder names
+        if (header === "") {
+            let placeholder = `_column_${i}`;
+            // Ensure placeholder doesn't collide with existing headers
+            while (usedHeaders.has(placeholder) || reservedHeaders.has(placeholder)) {
+                placeholder = `_column_${i}_${emptyHeaderCount++}`;
+            }
+            usedHeaders.add(placeholder);
+            result.push(placeholder);
+            renamedHeaders[placeholder] = "";
+            hasRenames = true;
+            continue;
+        }
+        if (!usedHeaders.has(header)) {
+            usedHeaders.add(header);
+            headerCount.set(header, 1);
+            result.push(header);
+            continue;
+        }
+        // Duplicate: find a unique suffix, avoiding collisions with already-present headers
+        let suffix = headerCount.get(header) ?? 1;
+        let candidate = `${header}_${suffix}`;
+        while (usedHeaders.has(candidate) || reservedHeaders.has(candidate)) {
+            suffix++;
+            candidate = `${header}_${suffix}`;
+        }
+        headerCount.set(header, suffix + 1);
+        usedHeaders.add(candidate);
+        result.push(candidate);
+        renamedHeaders[candidate] = header;
+        hasRenames = true;
+    }
+    return { headers: result, renamedHeaders: hasRenames ? renamedHeaders : null };
+}
+// =============================================================================
+// Column Utilities
+// =============================================================================
+/**
+ * Process columns configuration to extract keys and headers.
+ * Returns null if columns is empty or undefined.
+ *
+ * This function is used by both formatCsv (batch) and CsvFormatterStream (streaming)
+ * to normalize column configuration into separate key/header arrays.
+ *
+ * @param columns - Column configuration array (string names or ColumnConfig objects)
+ * @returns Object with keys (data access) and headers (output names), or null if empty
+ *
+ * @example
+ * ```ts
+ * processColumns(['name', { key: 'age', header: 'Age (years)' }])
+ * // { keys: ['name', 'age'], headers: ['name', 'Age (years)'] }
+ * ```
+ */
+export function processColumns(columns) {
+    if (!columns || columns.length === 0) {
+        return null;
+    }
+    const keys = columns.map(c => (typeof c === "string" ? c : c.key));
+    const headers = columns.map(c => (typeof c === "string" ? c : (c.header ?? c.key)));
+    return { keys, headers };
+}
+// =============================================================================
+// Row Validation Utilities
+// =============================================================================
+/** Pre-compiled regex for non-whitespace detection */
+const NON_WHITESPACE_REGEX = /\S/;
+/**
+ * Check if a row should be skipped as empty.
+ * When `shouldSkipEmpty` is "greedy", whitespace-only rows also count as empty.
+ *
+ * @param row - The row to check
+ * @param shouldSkipEmpty - true, false, or "greedy"
+ * @returns true if the row should be skipped
+ */
+export function isEmptyRow(row, shouldSkipEmpty) {
+    if (!shouldSkipEmpty) {
+        return false;
+    }
+    if (shouldSkipEmpty === "greedy") {
+        // Greedy: whitespace-only fields count as empty
+        for (const field of row) {
+            if (NON_WHITESPACE_REGEX.test(field)) {
+                return false;
+            }
+        }
+    }
+    else {
+        // Non-greedy: only truly empty strings count as empty
+        for (const field of row) {
+            if (field !== "") {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Check if all values in a row are empty strings.
+ * Used by skipRecordsWithEmptyValues option.
+ *
+ * @param row - The row to check
+ * @returns true if all fields are empty strings
+ */
+export function hasAllEmptyValues(row) {
+    return isEmptyRow(row, true);
+}

package/dist/browser/modules/csv/worker/index.browser.d.ts

@@ -0,0 +1,6 @@
+/**
+ * CSV Worker Module - Browser Entry Point
+ */
+export { CsvWorkerPool, CsvWorkerSession, hasWorkerSupport, getDefaultWorkerPool, terminateDefaultWorkerPool, parseWithPool, formatWithPool } from "./pool.browser.js";
+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";
+export { getWorkerBlobUrl, releaseWorkerBlobUrl } from "./worker-script.bundle.js";

package/dist/browser/modules/csv/worker/index.browser.js

@@ -0,0 +1,5 @@
+/**
+ * CSV Worker Module - Browser Entry Point
+ */
+export { CsvWorkerPool, CsvWorkerSession, hasWorkerSupport, getDefaultWorkerPool, terminateDefaultWorkerPool, parseWithPool, formatWithPool } from "./pool.browser.js";
+export { getWorkerBlobUrl, releaseWorkerBlobUrl } from "./worker-script.bundle.js";

package/dist/browser/modules/csv/worker/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CSV Worker Module - Node.js Entry Point
+ *
+ * Exports stub implementations. Web Workers are browser-only.
+ */
+export { CsvWorkerPool, CsvWorkerSession, hasWorkerSupport, getDefaultWorkerPool, terminateDefaultWorkerPool, parseWithPool, formatWithPool } from "./pool.js";
+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";

package/dist/browser/modules/csv/worker/index.js

@@ -0,0 +1,6 @@
+/**
+ * CSV Worker Module - Node.js Entry Point
+ *
+ * Exports stub implementations. Web Workers are browser-only.
+ */
+export { CsvWorkerPool, CsvWorkerSession, hasWorkerSupport, getDefaultWorkerPool, terminateDefaultWorkerPool, parseWithPool, formatWithPool } from "./pool.browser.js";

package/dist/browser/modules/csv/worker/pool.browser.d.ts

@@ -0,0 +1,193 @@
+/**
+ * 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";