@kanunilabs/pivotgrid-core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,787 @@
+import { P as PivotField, a as PivotControllerState, b as PivotLayoutState, c as PivotSelectionStats, d as PivotImportStatus, e as PivotControllerOptions, f as PivotEngineResult, F as FieldMoveEvent, C as CellClickEvent, E as ExportingEvent, g as PivotArea, D as DropIntent, h as PivotImportField, i as ExportFormat, j as ExportOptions, k as PivotCell, l as PivotDragIntentState, m as PivotReport, n as PivotReportState, o as PivotSelectionMode, p as PivotSelectionState, q as PivotCellValueAccessor, r as PivotCellTextAccessor, s as PivotPrefilter, t as PivotNode, u as PivotEngineRegistry, v as PivotValue, w as PivotConditionRule, x as PivotDictionary } from './pivot.worker-DQFl4fMu.js';
+export { y as CellPreparedEvent, z as CustomSummaryOptions, A as FieldDistinctEntry, B as FilterCondition, G as FilterGroup, H as FilterOperator, I as FlatCellMatrix, J as FlatPivotEngine, K as FlatRow, L as PivotCellTemplate, M as PivotControllerCallbacks, N as PivotDataSource, O as PivotGridRef, Q as PivotGroupInterval, R as PivotImportPreviewState, S as PivotLayoutProfile, T as PivotLocale, U as PivotPlugin, V as PivotSelectionRange, W as PivotStateStoringConfig, X as PivotSummaryDisplayMode, Y as PivotSummaryType, Z as PivotTheme, _ as PivotToolbarConfig, $ as PrefilterConditionSpec, a0 as PrefilterGroupSpec, a1 as WorkerComputeRequest, a2 as WorkerFilterRequest, a3 as WorkerFilterSpec, a4 as WorkerInitRequest, a5 as WorkerResponse, a6 as buildCellLookup, a7 as buildColPathsList, a8 as buildColumnHeaders, a9 as buildPivotAOA, aa as buildRowLabelCells, ab as computePivotMatrixAsync, ac as cssColorToRgb, ad as defaultPivotLayout, ae as destroyEngineWorker, af as escapeXmlText, ag as exportPivotData, ah as filterEmptySummaryTree, ai as filterPivotEngineAsync, aj as flattenExportRows, ak as flattenRowTree, al as flattenRowTreeTabular, am as flattenRowTreeTree, an as formatHeaderValue, ao as getCellVal, ap as getFieldDistinctValues, aq as getVisibleColLeaves, ar as getVisibleLeafCount, as as getVisibleMaxDepth, at as initPivotEngineAsync, au as reconfigurePivotEngineAsync, av as resolveColPath, aw as setActiveEngineGrid } from './pivot.worker-DQFl4fMu.js';
+
+type PivotStateListener = () => void;
+/** Immutable-snapshot state store with debounced localStorage persistence. */
+declare class PivotStateStore<TRow> {
+    private snapshot;
+    private listeners;
+    private storageKey;
+    private persistScheduled;
+    constructor(gridId: string, initialFields: PivotField<TRow>[]);
+    getSnapshot: () => PivotControllerState<TRow>;
+    subscribe: (listener: PivotStateListener) => (() => void);
+    setState(updates: Partial<PivotControllerState<TRow>>): void;
+    setFields(fields: PivotField<TRow>[]): void;
+    setLayout(updates: Partial<PivotLayoutState>): void;
+    setExpandedPaths(paths: string[] | Set<string>): void;
+    setExpandedColPaths(paths: string[] | Set<string>): void;
+    setSelectionStats(selectionStats: PivotSelectionStats | null): void;
+    setImportStatus(importStatus: PivotImportStatus): void;
+    setImportPreview(importPreview: PivotControllerState<TRow>['importPreview']): void;
+    private createInitialSnapshot;
+    private schedulePersist;
+    private persist;
+}
+
+interface PivotControllerEvents<TRow> {
+    stateChanged: PivotControllerState<TRow>;
+    engineStarted: {
+        gridId: string;
+    };
+    engineCompleted: PivotEngineResult;
+    engineError: Error;
+    fieldMove: FieldMoveEvent;
+    cellClick: CellClickEvent<TRow>;
+    reportChanged: {
+        activeReportId: string | null;
+    };
+    exporting: ExportingEvent;
+}
+interface PivotImportLabels {
+    initializing: string;
+    processing: string;
+    importError: string;
+    importWarning: string;
+    importSuccess: string;
+    dataImportUnsupported: string;
+    /** Shown when the user cancels an in-flight import. Optional (falls back to a default). */
+    cancelled?: string;
+    /** Cancel-button caption in the import progress dialog. Optional. */
+    cancel?: string;
+}
+/**
+ * Framework-agnostic pivot grid controller.
+ *
+ * Orchestrates field management, engine computation (via Web Worker),
+ * state persistence, export, and event emission. Consumed by React/Angular adapters.
+ *
+ * @typeParam TRow - Shape of source data rows.
+ */
+declare class PivotController<TRow> {
+    private store;
+    private events;
+    private options;
+    private reportService;
+    private engineService;
+    private importManager;
+    private importAbort?;
+    /** Full row set of a parsed import awaiting preview commit (kept out of observable state). */
+    private pendingImportRows;
+    private disposed;
+    constructor(options: PivotControllerOptions<TRow>);
+    subscribe: (listener: PivotStateListener) => (() => void);
+    getSnapshot: () => PivotControllerState<TRow>;
+    getState(): PivotControllerState<TRow>;
+    on<K extends keyof PivotControllerEvents<TRow>>(eventName: K, handler: (payload: PivotControllerEvents<TRow>[K]) => void): () => void;
+    updateOptions(options: Partial<PivotControllerOptions<TRow>>): void;
+    setFields(fields: PivotField<TRow>[]): void;
+    updateField(updatedField: PivotField<TRow>): void;
+    deleteField(fieldId: string): void;
+    changeFieldArea(fieldId: string, area: PivotArea): void;
+    removeField(fieldId: string): void;
+    moveField(fieldId: string, direction: 'start' | 'end' | 'left' | 'right'): void;
+    sortField(fieldId: string, direction: 'asc' | 'desc' | undefined): void;
+    sortFieldBySummary(rowFieldId: string, summaryFieldId: string, colPath: string): void;
+    clearAllSorting(): void;
+    applyFilter(fieldId: string, selectedValues: Set<any>, filterType: 'include' | 'exclude'): void;
+    clearFilter(fieldId: string): void;
+    setLayout(updates: Partial<PivotLayoutState>): void;
+    toggleExpanded(path: string): void;
+    expandPaths(paths: string[]): void;
+    collapsePaths(paths: string[]): void;
+    setExpandedPaths(paths: string[]): void;
+    toggleColExpanded(path: string): void;
+    expandColPaths(paths: string[]): void;
+    collapseColPaths(paths: string[]): void;
+    setExpandedColPaths(paths: string[]): void;
+    expandAll(): void;
+    collapseAll(): void;
+    setColumnWidths(widths: Record<string, number>): void;
+    setSelectionStats(selectionStats: PivotSelectionStats | null): void;
+    setDragActive(activeId: string | null): void;
+    setDragIntent(targetId: string | null, targetArea: string | null, intent: DropIntent): void;
+    resetDrag(): void;
+    calculateDropIntent(pointerX: number, pointerY: number, itemRect: {
+        width: number;
+        height: number;
+        left: number;
+        top: number;
+    }, previousIntent: DropIntent, isLastItem: boolean, orientation: 'horizontal' | 'vertical'): DropIntent;
+    commitDrag(fieldId: string, overId: string | null): Promise<void>;
+    /** Import a single uploaded file (worker-streamed for CSV/JSON/XML). */
+    importFile(file: File, labels: PivotImportLabels): Promise<void>;
+    /** Import one or more files at once, appending their rows (union fields). */
+    importFiles(files: FileList | File[], labels: PivotImportLabels): Promise<void>;
+    /** Import data fetched from a URL / backend API endpoint. */
+    importFromUrl(url: string, labels: PivotImportLabels, fetchInit?: RequestInit): Promise<void>;
+    /** Import an already-materialized array of rows (e.g. an API response). */
+    importData(rows: any[], labels: PivotImportLabels): Promise<void>;
+    /** Import delimited text pasted from the clipboard (auto-detects CSV/TSV). */
+    importText(text: string, labels: PivotImportLabels): Promise<void>;
+    /**
+     * Shared import driver: manages the abort/progress lifecycle and status
+     * dialog around any import source (`task` performs the actual parse).
+     */
+    private runImport;
+    /** Cancel an in-flight import started by {@link importFile}/{@link importFiles}/{@link importFromUrl}. */
+    cancelImport(): void;
+    /** Show a terminal import status message (e.g. clipboard empty / permission denied). */
+    showImportStatus(status: 'success' | 'error' | 'warning', title: string, messages: string[]): void;
+    /** Stash a parsed import and open the preview/column-mapping step. */
+    private openImportPreview;
+    /**
+     * Commit a previewed import using the reviewed column plan (include/exclude,
+     * caption + type overrides). Columns whose type changed are re-coerced.
+     */
+    commitImport(plan: (PivotImportField & {
+        include?: boolean;
+    })[] | undefined, labels: PivotImportLabels): void;
+    /** Discard a pending previewed import without applying it. */
+    cancelImportPreview(): void;
+    private showImportCancelled;
+    closeImportStatus(): void;
+    saveReport(name: string, isDefault: boolean): void;
+    updateCurrentReport(): void;
+    loadReport(id: string): void;
+    deleteReport(id: string): void;
+    setDefaultReport(id: string): void;
+    refreshEngine(): void;
+    exportData(format: ExportFormat | string, options?: ExportOptions): Promise<void>;
+    getRawData(): TRow[];
+    getEngineResult(): PivotEngineResult | null;
+    getCell(rowPath: string[], colPath: string[]): PivotCell | null;
+    resolveCellClick(event: CellClickEvent<TRow>): CellClickEvent<TRow>;
+    getAreaFields(area: PivotArea): PivotField<TRow>[];
+    private cellIndexLookups;
+    private getCellIndexLookup;
+    dispose(): void;
+    private normalizeOptions;
+    private setState;
+    private emitState;
+    private commitFields;
+    private setDragState;
+    private setImportStatus;
+    private loadDefaultReport;
+    private createReportState;
+    private applyReportState;
+    private collectNodePaths;
+}
+
+interface PivotEngineServiceConfig<TRow> {
+    getOptions: () => PivotControllerOptions<TRow>;
+    getState: () => PivotControllerState<TRow>;
+    getAreaFields: (area: PivotArea) => PivotField<TRow>[];
+    setState: (updates: Partial<PivotControllerState<TRow>>) => void;
+    onEngineStarted: (payload: {
+        gridId: string;
+    }) => void;
+    onEngineCompleted: (result: PivotEngineResult) => void;
+    onEngineError: (error: Error) => void;
+}
+declare class PivotEngineService<TRow> {
+    private config;
+    private initTimeout;
+    private computeTimeout;
+    private progressTimer;
+    private progressCompletionTimer;
+    private progressStartedAt;
+    private progressStartValue;
+    private progressCap;
+    private progressEstimateMs;
+    private initVersion;
+    private computeVersion;
+    private disposed;
+    private isInitComplete;
+    private forceNextReencode;
+    private hashes;
+    constructor(config: PivotEngineServiceConfig<TRow>);
+    refresh(): void;
+    refreshData(): void;
+    computeIfReady(): void;
+    dispose(): void;
+    private scheduleInit;
+    private runInit;
+    private scheduleReconfigure;
+    private runReconfigure;
+    private scheduleFilter;
+    private runFilter;
+    private scheduleComputeIfReady;
+    private runCompute;
+    /**
+     * Produce a fully-expanded engine snapshot on demand, WITHOUT mutating the
+     * grid's live state. Used by `expandAll` exports: the cached engineResult
+     * only contains nodes visible under the current expand/collapse state (the
+     * worker prunes collapsed subtrees and their cells), so a naive
+     * "expand everything" over that snapshot would silently drop collapsed rows.
+     * This requests a fresh worker compute with every path expanded and re-runs
+     * the same post-aggregation, sort and display-mode phases as {@link runCompute}
+     * so the result is identical in shape to what the grid would render if the
+     * user expanded all nodes manually.
+     */
+    computeFullyExpandedSnapshot(): Promise<PivotEngineResult>;
+    private startBuildProgress;
+    private tickBuildProgress;
+    private advanceBuildProgress;
+    private completeBuildProgress;
+    private stopBuildProgress;
+    private initialProgressFor;
+    private progressCapFor;
+    private estimateProgressDuration;
+    private handleEngineError;
+    private createStructuralFieldsHash;
+    private createFieldsHash;
+    private createFilterHash;
+    private serializeFilterValue;
+    private setHashCache;
+    private createSetHash;
+}
+
+interface FieldDropCommand {
+    fieldId: string;
+    overId: string | null;
+    dragIntent: PivotDragIntentState;
+    validateMove?: (event: FieldMoveEvent) => void | Promise<void>;
+}
+interface DropIntentRect {
+    width: number;
+    height: number;
+    left: number;
+    top: number;
+}
+declare class PivotFieldService {
+    static normalizeAreaIndexes<TRow>(fields: PivotField<TRow>[]): PivotField<TRow>[];
+    static sortField<TRow>(fields: PivotField<TRow>[], fieldId: string, direction: 'asc' | 'desc' | undefined): PivotField<TRow>[];
+    static sortFieldBySummary<TRow>(fields: PivotField<TRow>[], rowFieldId: string, summaryFieldId: string, colPath: string): PivotField<TRow>[];
+    static clearAllSorting<TRow>(fields: PivotField<TRow>[]): PivotField<TRow>[];
+    static updateField<TRow>(fields: PivotField<TRow>[], updatedField: PivotField<TRow>): PivotField<TRow>[];
+    static applyFilter<TRow>(fields: PivotField<TRow>[], fieldId: string, selectedValues: Set<any>, filterType: 'include' | 'exclude'): PivotField<TRow>[];
+    static clearFilter<TRow>(fields: PivotField<TRow>[], fieldId: string): PivotField<TRow>[];
+    static removeField<TRow>(fields: PivotField<TRow>[], fieldId: string): PivotField<TRow>[];
+    static deleteField<TRow>(fields: PivotField<TRow>[], fieldId: string): PivotField<TRow>[];
+    static changeFieldArea<TRow>(fields: PivotField<TRow>[], fieldId: string, area: PivotArea): PivotField<TRow>[];
+    static moveFieldByDirection<TRow>(fields: PivotField<TRow>[], fieldId: string, direction: 'start' | 'end' | 'left' | 'right'): PivotField<TRow>[];
+    static moveFieldFromDrop<TRow>(fields: PivotField<TRow>[], command: FieldDropCommand): Promise<PivotField<TRow>[]>;
+    static calculateDropIntent(pointerX: number, pointerY: number, itemRect: DropIntentRect, previousIntent: DropIntent, isLastItem: boolean, orientation?: 'horizontal' | 'vertical'): DropIntent;
+    private static isArea;
+}
+
+interface PivotExportServiceOptions<TRow> {
+    format: ExportFormat | string;
+    exportOptions?: ExportOptions;
+    controllerOptions: PivotControllerOptions<TRow>;
+    state: PivotControllerState<TRow>;
+    emitExporting: (event: ExportingEvent) => void;
+}
+declare class PivotExportService {
+    static exportData<TRow>({ format, exportOptions, controllerOptions, state, emitExporting }: PivotExportServiceOptions<TRow>): Promise<void>;
+}
+
+declare class PivotReportService {
+    private manager;
+    constructor(gridId: string);
+    getReports(): PivotReport[];
+    getDefaultReport(): PivotReport | null;
+    saveReport(name: string, state: PivotReportState, isDefault: boolean): PivotReport;
+    updateReport(id: string, state: PivotReportState): PivotReport | null;
+    deleteReport(id: string): PivotReport[];
+    setDefaultReport(id: string): PivotReport[];
+}
+
+declare class PivotSelectionModel {
+    static start(row: number, column: number, mode: PivotSelectionMode): PivotSelectionState;
+    static extend(state: PivotSelectionState | null, row: number, column: number, mode: PivotSelectionMode): PivotSelectionState | null;
+    static finish(state: PivotSelectionState | null): PivotSelectionState | null;
+    static containsCell(state: PivotSelectionState | null, row: number, column: number): boolean;
+    static calculateStats(state: PivotSelectionState | null, valueAccessor: PivotCellValueAccessor): PivotSelectionStats | null;
+    static toTsv(state: PivotSelectionState | null, textAccessor: PivotCellTextAccessor): string;
+    private static getBounds;
+}
+
+type PivotEventMap = Record<string, any>;
+type PivotEventHandler<TPayload> = (payload: TPayload) => void;
+declare class PivotEventEmitter<TEvents extends PivotEventMap> {
+    private handlers;
+    on<K extends keyof TEvents>(eventName: K, handler: PivotEventHandler<TEvents[K]>): () => void;
+    off<K extends keyof TEvents>(eventName: K, handler: PivotEventHandler<TEvents[K]>): void;
+    emit<K extends keyof TEvents>(eventName: K, payload: TEvents[K]): void;
+    clear(): void;
+}
+
+declare const MAX_C = 67108864;
+declare function cellHash(rId: number, cId: number): number;
+declare function cellHashRow(hash: number): number;
+declare function cellHashCol(hash: number): number;
+
+declare class PivotCellAggregator<TRow> {
+    private accumulators;
+    private dataFields;
+    constructor(dataFields: PivotField<TRow>[]);
+    push(index: number, columnarData: Record<string, {
+        type: 'int32' | 'float64';
+        array: Int32Array | Float64Array;
+    }>, dictionary: string[]): void;
+    merge(other: PivotCellAggregator<TRow>): void;
+    finalize(): Record<string, number>;
+}
+
+declare class FastTrie {
+    size: number;
+    nodeToParent: Int32Array;
+    nodeToVal: Int32Array;
+    nodeToDepth: Int32Array;
+    nodeChildCount: Int32Array;
+    childrenMap: Map<number, Map<number, number>>;
+    constructor(capacity: number);
+    private expandCapacity;
+    insert(pathArray: Int32Array, len: number): number;
+}
+
+/**
+ * Compile a user-facing formula string like `[Sales] * [Tax] + 5`
+ * into a CSP-safe evaluator function.
+ *
+ * @param formulaString  The raw formula with [FieldCaption] references
+ * @param fieldMap       Map of caption → data key (e.g. "Sales" → "sales")
+ * @returns  An evaluator `(context) => number`, or null if the formula is unsafe/invalid
+ */
+declare function compileSafeFormula(formulaString: string, fieldMap: Map<string, string>): ((context: Record<string, any>) => number) | null;
+/**
+ * Test-compile a formula and throw on error (for UI validation).
+ */
+declare function testSafeFormula(formulaString: string, fieldMap: Map<string, string>): void;
+
+declare function filterRecords<TRow>(records: TRow[], fields: PivotField<TRow>[], prefilter?: PivotPrefilter): TRow[];
+declare function filterRecordsAsync<TRow>(records: TRow[], fields: PivotField<TRow>[], prefilter?: PivotPrefilter): Promise<TRow[]>;
+
+declare function sortPivotTree(nodes: PivotNode[], fields: PivotField<any>[], engineResult: PivotEngineResult, dataFields: PivotField<any>[], isRowTree: boolean, locale?: string, cellMapCache?: Map<number, number>): void;
+
+declare function executePostAggregationPhase<TRow>(engineResult: PivotEngineResult, dataFields: PivotField<TRow>[], registry?: PivotEngineRegistry): void;
+declare function executeSummaryDisplayModesPhase<TRow>(engineResult: PivotEngineResult, dataFields: PivotField<TRow>[]): void;
+
+declare function extractGroupValue<TRow>(row: TRow, field: PivotField<TRow>): PivotValue;
+
+type DateFormatContext = 'grid' | 'chart' | 'export';
+type DateGranularity = 'year' | 'quarter' | 'month' | 'day' | 'dayOfWeek' | string | number;
+declare class DateFormatter {
+    private static intlCache;
+    private static stringCache;
+    /**
+     * Formats a raw grouped date value into a human-readable string.
+     * Cached to ensure 0 FPS drop on 500k+ rows.
+     */
+    static format(rawValue: any, context: DateFormatContext, locale: string, granularity?: DateGranularity): string;
+    static clearCache(): void;
+}
+
+declare class ExportStreamController {
+    private worker;
+    private static sharedWorker;
+    private static workerErrorCount;
+    private static readonly MAX_WORKER_ERRORS;
+    private static getOrCreateWorker;
+    /** Force-terminate and release the shared worker (e.g. on app teardown). */
+    static disposeWorker(): void;
+    constructor();
+    streamToCSV(data: any[], fields: PivotField<any>[], fileName: string, locale?: string, onProgress?: (percent: number) => void, signal?: AbortSignal): Promise<void>;
+    streamToExcelXML(data: any[], fields: PivotField<any>[], fileName: string, locale?: string, onProgress?: (percent: number) => void, signal?: AbortSignal): Promise<void>;
+    private processChunkInWorker;
+}
+
+interface AdvancedExportRequest {
+    format: 'excel-list' | 'excel-pivot' | 'pdf';
+    /** Flat source records (used by `excel-list`). */
+    listRecords: any[];
+    /** Visible fields for the flat list export. */
+    visibleListFields: PivotField[];
+    engineResult: PivotEngineResult;
+    rowFields: PivotField[];
+    colFields: PivotField[];
+    dataFields: PivotField[];
+    layout: PivotLayoutState;
+    expandedPaths: Set<string>;
+    expandedColPaths: Set<string>;
+    allExpanded: boolean;
+    fileName: string;
+    locale: string;
+    signal?: AbortSignal;
+    onProgress?: (percent: number) => void;
+}
+type AdvancedExporter = (req: AdvancedExportRequest) => Promise<void>;
+/** Called by the Enterprise package to enable Excel/PDF export. */
+declare function registerAdvancedExporter(fn: AdvancedExporter): void;
+declare function getAdvancedExporter(): AdvancedExporter | null;
+
+/**
+ * Convert Intl.NumberFormatOptions to an Excel numFmt string.
+ * Handles currency, percent, decimal, and basic integer formats.
+ */
+declare function intlFormatToExcelNumFmt(format: Intl.NumberFormatOptions | Intl.DateTimeFormatOptions | ((value: number) => string) | undefined, dataType?: string): string | undefined;
+/**
+ * Format a cell value using the field's format configuration.
+ * Returns the formatted string for display in PDF/CSV/Print export.
+ */
+declare function formatCellValue(value: unknown, field: PivotField | undefined, locale?: string): string;
+/**
+ * High-performance cached formatter for bulk cell formatting.
+ * Avoids creating Intl.NumberFormat instances per-cell.
+ */
+declare function formatCellValueCached(value: unknown, field: PivotField | undefined, locale?: string): string;
+/**
+ * Convert a PivotConditionRule to ExcelJS cell style properties.
+ * Used for conditional formatting export to Excel.
+ */
+declare function conditionRuleToExcelStyle(rule: PivotConditionRule, value: number): {
+    font?: Record<string, unknown>;
+    fill?: Record<string, unknown>;
+} | null;
+/**
+ * Clear the formatter cache. Call when locale changes.
+ */
+declare function clearFormatCache(): void;
+
+declare class PivotReportManager {
+    private storageKey;
+    constructor(storageKey: string);
+    /**
+     * Retrieves all saved reports from localStorage
+     */
+    getReports(): PivotReport[];
+    /**
+     * Retrieves the default report, if one exists
+     */
+    getDefaultReport(): PivotReport | null;
+    /**
+     * Saves a new report
+     */
+    saveReport(name: string, state: PivotReportState, isDefault?: boolean): PivotReport;
+    /**
+     * Updates an existing report (Overwrite)
+     */
+    updateReport(id: string, state: PivotReportState): PivotReport | null;
+    /**
+     * Creates a copy of an existing report
+     */
+    saveAs(id: string, newName: string): PivotReport | null;
+    /**
+     * Deletes a report
+     */
+    deleteReport(id: string): void;
+    /**
+     * Sets a specific report as the default
+     */
+    setDefaultReport(id: string): void;
+    private persist;
+}
+
+type ImportFormat = 'json' | 'csv' | 'xml' | 'xlsx';
+interface ImportSnapshot<TRow = any> {
+    version: string;
+    type: 'FULL_SNAPSHOT' | 'LAYOUT_ONLY' | 'DATA_ONLY';
+    timestamp: string;
+    data?: TRow[];
+    fields?: PivotField<TRow>[];
+    layout?: PivotLayoutState;
+    expandedPaths?: string[];
+    preferences?: Record<string, any>;
+}
+interface IFileReader {
+    read(file: File): Promise<any[]>;
+    supports(file: File): boolean;
+}
+interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+
+/** Progress update surfaced while a file is parsed in the worker. */
+interface ImportProgress {
+    /** Coarse pipeline stage: reading | parsing | typing | finalizing. */
+    phase: string;
+    /** Overall completion, 0..100. */
+    percent: number;
+}
+/** File kinds the import worker can parse off the main thread. */
+type ImportWorkerKind = 'csv' | 'json' | 'xml';
+/** Result posted back by the worker once parsing completes. */
+type ImportWorkerResult = {
+    mode: 'data';
+    data: any[];
+    fields: PivotField<any>[];
+} | {
+    mode: 'raw';
+    value: any;
+};
+interface ParseFileOptions {
+    onProgress?: (p: ImportProgress) => void;
+    signal?: AbortSignal;
+}
+/**
+ * Drives the import Web Worker for a single file: streams progress, resolves
+ * with the parsed payload, and supports cooperative cancellation.
+ *
+ * Mirrors {@link ExportStreamController}, but imports are one-shot so each job
+ * gets a dedicated worker that is terminated on completion, error or cancel —
+ * `terminate()` also gives us instant, reliable cancellation mid-parse (a
+ * synchronous parse loop cannot otherwise be interrupted).
+ */
+declare class ImportStreamController {
+    private static jobCounter;
+    /** Whether Web Workers are available in the current environment. */
+    static isSupported(): boolean;
+    /**
+     * Parse `file` in the worker. Resolves with the worker payload, rejects with
+     * an `AbortError` DOMException if `signal` is aborted, or a generic Error on
+     * worker failure.
+     */
+    parseFile(file: Blob, kind: ImportWorkerKind, opts?: ParseFileOptions): Promise<ImportWorkerResult>;
+}
+
+interface ImportManagerOptions {
+    /**
+     * Reject files larger than this many bytes before reading them, to guard
+     * against out-of-memory / browser-crash from oversized uploads. Defaults to
+     * 500 MB; pass 0 to disable the guard.
+     */
+    maxFileSizeBytes?: number;
+}
+interface ImportResult {
+    snapshot: ImportSnapshot;
+    validation: ValidationResult;
+    /** True when the import was cancelled via the abort signal before completing. */
+    cancelled?: boolean;
+}
+interface ProcessFileStreamingOptions {
+    onProgress?: (p: ImportProgress) => void;
+    signal?: AbortSignal;
+}
+interface ProcessFromUrlOptions extends ProcessFileStreamingOptions {
+    /** Extra fetch() init (headers, method, credentials, …). */
+    fetchInit?: RequestInit;
+}
+declare class ImportManager {
+    private readers;
+    private maxFileSizeBytes;
+    private stream;
+    constructor(options?: ImportManagerOptions);
+    /**
+     * Processes an uploaded file synchronously (whole-file read + parse on the
+     * calling thread). Retained for back-compat and non-worker environments;
+     * prefer {@link processFileStreaming} for large files.
+     */
+    processFile(file: File): Promise<{
+        snapshot: ImportSnapshot;
+        validation: ValidationResult;
+    }>;
+    /**
+     * Processes an uploaded file, offloading CSV/JSON parsing to a Web Worker so
+     * the UI stays responsive on large files, reporting progress and honoring
+     * cancellation. Excel (and environments without workers) transparently fall
+     * back to the synchronous reader path.
+     */
+    processFileStreaming(file: File, options?: ProcessFileStreamingOptions): Promise<ImportResult>;
+    /**
+     * Import an already-materialized array of row objects (e.g. an API/JSON
+     * response). Fields are auto-discovered; values are used as-is (call
+     * {@link coerceRecords} first if they are stringly-typed).
+     */
+    processFromData(rows: any[], options?: ProcessFileStreamingOptions): Promise<ImportResult>;
+    /**
+     * Import delimited text (e.g. a clipboard paste from Excel/Sheets, which is
+     * tab-separated). Delimiter is auto-detected; values are typed via the shared
+     * CSV pipeline.
+     */
+    processFromText(text: string, options?: ProcessFileStreamingOptions): Promise<ImportResult>;
+    /**
+     * Fetch data from a URL (or backend API) and import it. The response is
+     * wrapped as a File so the format is detected from the URL extension /
+     * content-type and parsed through the same worker pipeline.
+     */
+    processFromUrl(url: string, options?: ProcessFromUrlOptions): Promise<ImportResult>;
+    /**
+     * Import one or more files, appending their rows into a single dataset with a
+     * unioned field set. Progress is aggregated across files; any cancellation
+     * aborts the whole batch.
+     */
+    processFiles(files: FileList | File[], options?: ProcessFileStreamingOptions): Promise<ImportResult>;
+    private assertSize;
+    /** Which worker parse path applies to this file, or null for Excel/unknown. */
+    private workerKind;
+    private isAbort;
+    private cancelledResult;
+    /** Build a result from reader/worker content (raw data array or a snapshot object). */
+    private buildFromContent;
+    /** Build a DATA_ONLY result from a raw row array, reusing worker-computed fields when supplied. */
+    private buildDataResult;
+}
+
+/**
+ * Dedicated delimited-text reader (CSV / TSV / plain text).
+ *
+ * Reads the file as UTF-8 TEXT (not raw bytes), so UTF-8 / Turkish / emoji
+ * content is preserved instead of being mis-decoded as ANSI. Parsing/typing is
+ * delegated to the shared {@link parseCsvToRows} pipeline (delimiter
+ * auto-detect, RFC-4180 quoting, per-column type inference and locale-aware
+ * coercion, leading-zero ids kept as strings) — the same code path the import
+ * worker runs. This is used in preference to the SheetJS path for delimited
+ * files.
+ */
+declare class CsvReader implements IFileReader {
+    supports(file: File): boolean;
+    read(file: File): Promise<any[]>;
+    /** Parse delimited text into typed row objects. Exposed for testing. */
+    static parse(text: string): Record<string, unknown>[];
+}
+
+/**
+ * Dependency-free XML reader for tabular data exports.
+ *
+ * Works in Node, Web Workers and the browser (no `DOMParser` needed). Handles
+ * the common "rows" shapes:
+ *   <data><record><a>1</a><b>x</b></record> … </data>   (element fields)
+ *   <rows><row id="1" name="x"/> … </rows>              (attribute fields)
+ *   <root><a>1</a><b>2</b></root>                        (single flat record)
+ * Attributes and leaf child-elements both become columns; values are typed with
+ * the shared {@link coerceRecords} pipeline (locale numbers, dates, booleans;
+ * leading-zero ids preserved). Prototype-polluting keys are neutralized.
+ */
+declare class XmlReader implements IFileReader {
+    supports(file: File): boolean;
+    read(file: File): Promise<any[]>;
+    /** Parse XML text into typed row objects. Exposed for testing. */
+    static parse(text: string): Record<string, unknown>[];
+}
+
+declare class DataNormalizer {
+    /**
+     * Generates basic PivotFields from an array of raw data objects.
+     * Scans a sample size of rows to determine data types.
+     */
+    static extractFieldsFromData(data: any[], sampleSize?: number): PivotField<any>[];
+    /**
+     * Build pivot fields from a reviewed import plan (column mapping): explicit
+     * caption + dataType per column, in the plan's order. Applies the same
+     * area-assignment heuristic as {@link extractFieldsFromData} (first
+     * string/date → row, first number → data).
+     */
+    static buildFieldsFromPlan(plan: {
+        dataField: string;
+        caption: string;
+        dataType: 'string' | 'number' | 'date' | 'boolean';
+    }[], data?: any[], sampleSize?: number): PivotField<any>[];
+    private static isAutoRowCandidate;
+    private static isAutoDataCandidate;
+    private static isHighCardinalityStringColumn;
+    private static isIdentifierLikeKey;
+    /** Union column keys across a sample of rows, preserving first-seen order. */
+    private static collectKeys;
+    private static inferType;
+    private static formatCaption;
+}
+
+type CellType = 'string' | 'number' | 'date' | 'boolean';
+/** Strip a leading UTF-8/UTF-16 BOM if present. */
+declare function stripBom(text: string): string;
+/**
+ * Auto-detect the delimiter of a delimited-text sample by counting candidate
+ * separators outside of quotes on the first few lines. Supports comma,
+ * semicolon, tab and pipe (covers Excel-locale CSV and TSV).
+ */
+declare function detectDelimiter(sample: string): string;
+/**
+ * Parse RFC-4180-style delimited text into a matrix of string cells.
+ * Handles quoted fields, escaped quotes (`""`), embedded newlines and
+ * mixed CRLF/LF line endings. The delimiter is auto-detected when omitted.
+ *
+ * `onProgress` (optional) is invoked periodically with the fraction of the
+ * input consumed (0..1) so long parses run in a worker can report progress.
+ */
+declare function parseDelimited(text: string, delimiter?: string, onProgress?: (fraction: number) => void): string[][];
+/** Lenient boolean parse used for COERCION within a known boolean column. */
+declare function parseBoolean(raw: unknown): boolean | null;
+/**
+ * Parse a locale-formatted number: handles thousands/decimal separators in
+ * both `1,234.56` and `1.234,56` conventions, currency symbols, percent,
+ * spaces (incl. non-breaking) and accounting parentheses for negatives.
+ * Returns null when the input is not a number.
+ */
+declare function parseLocaleNumber(raw: unknown): number | null;
+/**
+ * Parse a variety of common date formats to a Date: ISO (date or datetime),
+ * `yyyy/mm/dd`, `yyyy.mm.dd`, and `dd/mm/yyyy`/`mm/dd/yyyy` (disambiguated by
+ * the day value when possible, defaulting to day-first). Plain integers and
+ * separatorless strings are intentionally NOT treated as dates.
+ */
+declare function parseFlexibleDate(raw: unknown): Date | null;
+/** Classify a single raw cell value into a pivot data type (or 'blank'). */
+declare function classifyValue(val: unknown): CellType | 'blank';
+/**
+ * Infer a column's type from a set of sampled values by majority vote over
+ * non-blank cells. Ties and empty columns default to 'string'.
+ */
+declare function inferColumnType(values: unknown[]): CellType;
+/**
+ * Coerce a raw value to the target column type. Returns null for blanks and
+ * for values that cannot be represented in the target type (so a stray text
+ * cell in a numeric column becomes empty rather than corrupting aggregation).
+ */
+declare function coerceValue(val: unknown, type: CellType): unknown;
+/** Return a key safe to assign as an own property (renames prototype-polluting keys). */
+declare function safeKey(key: string): string;
+/**
+ * Defensively neutralize prototype-polluting own keys in already-parsed rows
+ * (e.g. from SheetJS/JSON, whose keys come from untrusted files). Returns the
+ * same array untouched when nothing dangerous is present (the common case).
+ */
+declare function sanitizeRows<T extends Record<string, unknown>>(rows: T[]): Record<string, unknown>[];
+interface CsvParseProgress {
+    phase: 'parsing' | 'typing';
+    /** Overall completion 0..100. */
+    percent: number;
+}
+/** Ensure unique, non-empty header names (duplicates get a numeric suffix); prototype-safe. */
+declare function dedupeHeaders(headers: string[]): string[];
+/**
+ * Infer per-column types from a sample of already-parsed string/loose records
+ * and coerce every cell (locale numbers, dates, booleans; leading-zero ids kept
+ * as strings), returning fresh prototype-safe row objects. Shared by any source
+ * that yields untyped records (XML, and future sources). `onProgress` reports
+ * typing completion 0..100.
+ */
+declare function coerceRecords(records: Record<string, unknown>[], onProgress?: (p: CsvParseProgress) => void): Record<string, unknown>[];
+/**
+ * Full delimited-text → typed-row pipeline: BOM strip, delimiter auto-detect,
+ * RFC-4180 parse, header dedupe, per-column type inference from a sample and
+ * per-cell coercion (locale numbers, dates, booleans; leading-zero ids kept as
+ * strings). Optional `onProgress` reports overall completion (parse 0→60%,
+ * typing 60→100%) so a worker can surface a progress bar. This is the single
+ * implementation shared by {@link CsvReader} (sync) and the import worker.
+ */
+declare function parseCsvToRows(text: string, onProgress?: (p: CsvParseProgress) => void): Record<string, unknown>[];
+
+declare const tr: PivotDictionary;
+
+declare const en: PivotDictionary;
+
+declare const de: PivotDictionary;
+
+declare const fr: PivotDictionary;
+
+declare const es: PivotDictionary;
+
+declare const it: PivotDictionary;
+
+declare const pt: PivotDictionary;
+
+declare const ru: PivotDictionary;
+
+declare const ar: PivotDictionary;
+
+declare const zhCN: PivotDictionary;
+
+declare const ja: PivotDictionary;
+
+declare const ko: PivotDictionary;
+
+export { type AdvancedExportRequest, type AdvancedExporter, CellClickEvent, type CellType, type CsvParseProgress, CsvReader, DataNormalizer, type DateFormatContext, DateFormatter, type DateGranularity, DropIntent, ExportFormat, ExportOptions, ExportStreamController, ExportingEvent, FastTrie, FieldMoveEvent, type IFileReader, type ImportFormat, ImportManager, type ImportManagerOptions, type ImportProgress, type ImportResult, type ImportSnapshot, ImportStreamController, type ImportWorkerKind, type ImportWorkerResult, MAX_C, type ParseFileOptions, PivotArea, PivotCell, PivotCellAggregator, PivotCellTextAccessor, PivotCellValueAccessor, PivotConditionRule, PivotController, type PivotControllerEvents, PivotControllerOptions, PivotControllerState, PivotDictionary, PivotDragIntentState, PivotEngineRegistry, PivotEngineResult, PivotEngineService, type PivotEngineServiceConfig, PivotEventEmitter, type PivotEventHandler, type PivotEventMap, PivotExportService, PivotField, PivotFieldService, PivotImportField, type PivotImportLabels, PivotImportStatus, PivotLayoutState, PivotNode, PivotPrefilter, PivotReport, PivotReportManager, PivotReportService, PivotReportState, PivotSelectionMode, PivotSelectionModel, PivotSelectionState, PivotSelectionStats, type PivotStateListener, PivotStateStore, PivotValue, type ProcessFileStreamingOptions, type ProcessFromUrlOptions, type ValidationResult, XmlReader, ar, cellHash, cellHashCol, cellHashRow, classifyValue, clearFormatCache, coerceRecords, coerceValue, compileSafeFormula, conditionRuleToExcelStyle, de, dedupeHeaders, detectDelimiter, en, es, executePostAggregationPhase, executeSummaryDisplayModesPhase, extractGroupValue, filterRecords, filterRecordsAsync, formatCellValue, formatCellValueCached, fr, getAdvancedExporter, inferColumnType, intlFormatToExcelNumFmt, it, ja, ko, parseBoolean, parseCsvToRows, parseDelimited, parseFlexibleDate, parseLocaleNumber, pt, registerAdvancedExporter, ru, safeKey, sanitizeRows, sortPivotTree, stripBom, testSafeFormula, tr, zhCN };