@cj-tech-master/excelts 1.5.0 → 1.6.1

package/dist/esm/xlsx/xlsx.js

@@ -105,6 +105,8 @@ class XLSX {
         Object.values(model.tables).forEach((table) => {
             tableXform.reconcile(table, tableOptions);
         });
+        // Reconcile pivot tables - link pivot tables to worksheets and cache data
+        this._reconcilePivotTables(model);
         const sheetOptions = {
             styles: model.styles,
             sharedStrings: model.sharedStrings,
@@ -114,7 +116,8 @@ class XLSX {
             drawings: model.drawings,
             comments: model.comments,
             tables: model.tables,
-            vmlDrawings: model.vmlDrawings
+            vmlDrawings: model.vmlDrawings,
+            pivotTables: model.pivotTablesIndexed
         };
         model.worksheets.forEach((worksheet) => {
             worksheet.relationships = model.worksheetRels[worksheet.sheetNo];
@@ -132,6 +135,136 @@ class XLSX {
         delete model.drawings;
         delete model.drawingRels;
         delete model.vmlDrawings;
+        // Clean up raw pivot table data after reconciliation
+        delete model.pivotTableRels;
+        delete model.pivotCacheDefinitionRels;
+    }
+    /**
+     * Reconcile pivot tables by linking them to worksheets and their cache data.
+     * This builds a complete pivot table model ready for writing.
+     */
+    _reconcilePivotTables(model) {
+        // Skip if no pivot tables were loaded (object is empty or undefined)
+        const rawPivotTables = model.pivotTables || {};
+        if (typeof rawPivotTables !== "object" || Object.keys(rawPivotTables).length === 0) {
+            // Ensure pivotTables is an empty array (not an object)
+            model.pivotTables = [];
+            // Also create an empty indexed object for worksheet reconciliation
+            model.pivotTablesIndexed = {};
+            return;
+        }
+        // Build mapping from definition name to cacheId
+        const definitionToCacheId = this._buildDefinitionToCacheIdMap(model);
+        // Build a map of cache IDs to their definitions and records
+        const cacheMap = new Map();
+        // Process cache definitions
+        Object.entries(model.pivotCacheDefinitions || {}).forEach(([name, definition]) => {
+            // Get the cacheId from the mapping (derived from workbook.xml pivotCaches)
+            const cacheId = definitionToCacheId.get(name);
+            if (cacheId !== undefined) {
+                const recordsName = name.replace("Definition", "Records");
+                cacheMap.set(cacheId, {
+                    definition,
+                    records: model.pivotCacheRecords?.[recordsName],
+                    definitionName: name
+                });
+            }
+        });
+        // Process pivot tables and link to worksheets
+        const loadedPivotTables = [];
+        // Create indexed object for worksheet reconciliation (keyed by relative path)
+        const pivotTablesIndexed = {};
+        Object.entries(rawPivotTables).forEach(([pivotName, pivotTable]) => {
+            const pt = pivotTable;
+            const tableNumber = this._extractTableNumber(pivotName);
+            // Get cache data for this pivot table
+            const cacheData = cacheMap.get(pt.cacheId);
+            // Build complete pivot table model
+            const completePivotTable = {
+                // Core model data
+                ...pt,
+                tableNumber,
+                // Link to cache data
+                cacheDefinition: cacheData?.definition,
+                cacheRecords: cacheData?.records,
+                // Reconstruct cacheFields from definition for compatibility
+                cacheFields: cacheData?.definition?.cacheFields || [],
+                // Determine rows, columns, values from parsed data
+                rows: pt.rowFields.filter(f => f >= 0),
+                columns: pt.colFields.filter(f => f >= 0 && f !== -2),
+                values: pt.dataFields.map(df => df.fld),
+                // Determine metric from dataFields
+                metric: this._determineMetric(pt.dataFields),
+                // Preserve formatting options
+                applyWidthHeightFormats: pt.applyWidthHeightFormats || "0"
+            };
+            loadedPivotTables.push(completePivotTable);
+            // Index by relative path for worksheet reconciliation
+            pivotTablesIndexed[`../pivotTables/${pivotName}.xml`] = completePivotTable;
+        });
+        // Sort by table number to maintain order
+        loadedPivotTables.sort((a, b) => a.tableNumber - b.tableNumber);
+        // Replace pivotTables object with the processed array
+        // This is what the Workbook model setter expects
+        model.pivotTables = loadedPivotTables;
+        // Also keep indexed version for worksheet reconciliation
+        model.pivotTablesIndexed = pivotTablesIndexed;
+        // Also keep as loadedPivotTables for backward compatibility
+        model.loadedPivotTables = loadedPivotTables;
+    }
+    /**
+     * Extract table number from pivot table name (e.g., "pivotTable1" -> 1)
+     */
+    _extractTableNumber(name) {
+        const match = name.match(/pivotTable(\d+)/);
+        return match ? parseInt(match[1], 10) : 1;
+    }
+    /**
+     * Build a mapping from rId to cacheId using pivotCaches from workbook.xml
+     * and workbookRels to determine which definition file corresponds to which cacheId
+     */
+    _buildCacheIdMap(model) {
+        const rIdToCacheId = new Map();
+        // pivotCaches from workbook.xml contains {cacheId, rId} mappings
+        const pivotCaches = model.pivotCaches || [];
+        for (const cache of pivotCaches) {
+            if (cache.cacheId && cache.rId) {
+                rIdToCacheId.set(cache.rId, parseInt(cache.cacheId, 10));
+            }
+        }
+        return rIdToCacheId;
+    }
+    /**
+     * Build a mapping from definition name to cacheId
+     */
+    _buildDefinitionToCacheIdMap(model) {
+        const definitionToCacheId = new Map();
+        const rIdToCacheId = this._buildCacheIdMap(model);
+        const workbookRels = model.workbookRels || [];
+        // Map workbook rels to get definitionNumber -> cacheId mapping
+        for (const rel of workbookRels) {
+            if (rel.Type === XLSX.RelType.PivotCacheDefinition && rel.Target) {
+                // Extract definition number from target (e.g., "pivotCache/pivotCacheDefinition1.xml" -> 1)
+                const match = rel.Target.match(/pivotCacheDefinition(\d+)\.xml/);
+                if (match) {
+                    const defName = `pivotCacheDefinition${match[1]}`;
+                    const cacheId = rIdToCacheId.get(rel.Id);
+                    if (cacheId !== undefined) {
+                        definitionToCacheId.set(defName, cacheId);
+                    }
+                }
+            }
+        }
+        return definitionToCacheId;
+    }
+    /**
+     * Determine the aggregation metric from dataFields
+     */
+    _determineMetric(dataFields) {
+        if (dataFields.length > 0 && dataFields[0].subtotal === "count") {
+            return "count";
+        }
+        return "sum";
     }
     async _processWorksheetEntry(stream, model, sheetNo, options, path) {
         const xform = new WorkSheetXform(options);
@@ -234,6 +367,37 @@ class XLSX {
             stream.pipe(streamBuf);
         });
     }
+    async _processPivotTableEntry(stream, model, name) {
+        const xform = new PivotTableXform();
+        const pivotTable = await xform.parseStream(stream);
+        if (pivotTable) {
+            model.pivotTables[name] = pivotTable;
+        }
+    }
+    async _processPivotTableRelsEntry(stream, model, name) {
+        const xform = new RelationshipsXform();
+        const relationships = await xform.parseStream(stream);
+        model.pivotTableRels[name] = relationships;
+    }
+    async _processPivotCacheDefinitionEntry(stream, model, name) {
+        const xform = new PivotCacheDefinitionXform();
+        const cacheDefinition = await xform.parseStream(stream);
+        if (cacheDefinition) {
+            model.pivotCacheDefinitions[name] = cacheDefinition;
+        }
+    }
+    async _processPivotCacheDefinitionRelsEntry(stream, model, name) {
+        const xform = new RelationshipsXform();
+        const relationships = await xform.parseStream(stream);
+        model.pivotCacheDefinitionRels[name] = relationships;
+    }
+    async _processPivotCacheRecordsEntry(stream, model, name) {
+        const xform = new PivotCacheRecordsXform();
+        const cacheRecords = await xform.parseStream(stream);
+        if (cacheRecords) {
+            model.pivotCacheRecords[name] = cacheRecords;
+        }
+    }
     async read(stream, options) {
         // Use streaming unzip with fflate
         const allFiles = {};
@@ -343,7 +507,13 @@ class XLSX {
             drawingRels: {},
             comments: {},
             tables: {},
-            vmlDrawings: {}
+            vmlDrawings: {},
+            // Pivot table storage for loaded files
+            pivotTables: {},
+            pivotTableRels: {},
+            pivotCacheDefinitions: {},
+            pivotCacheDefinitionRels: {},
+            pivotCacheRecords: {}
         };
         // Convert fflate format to JSZip-like structure for compatibility
         const entries = Object.keys(zipData).map(name => ({
@@ -391,6 +561,9 @@ class XLSX {
                             model.views = workbook.views;
                             model.properties = workbook.properties;
                             model.calcProperties = workbook.calcProperties;
+                            // pivotCaches contains the mapping from rId to cacheId
+                            // needed for linking pivot tables to their cache data
+                            model.pivotCaches = workbook.pivotCaches;
                             break;
                         }
                         case "xl/sharedStrings.xml":
@@ -459,6 +632,33 @@ class XLSX {
                                 await this._processThemeEntry(stream, model, match[1]);
                                 break;
                             }
+                            // Pivot table files
+                            match = entryName.match(/xl\/pivotTables\/(pivotTable\d+)[.]xml/);
+                            if (match) {
+                                await this._processPivotTableEntry(stream, model, match[1]);
+                                break;
+                            }
+                            match = entryName.match(/xl\/pivotTables\/_rels\/(pivotTable\d+)[.]xml[.]rels/);
+                            if (match) {
+                                await this._processPivotTableRelsEntry(stream, model, match[1]);
+                                break;
+                            }
+                            // Pivot cache files
+                            match = entryName.match(/xl\/pivotCache\/(pivotCacheDefinition\d+)[.]xml/);
+                            if (match) {
+                                await this._processPivotCacheDefinitionEntry(stream, model, match[1]);
+                                break;
+                            }
+                            match = entryName.match(/xl\/pivotCache\/_rels\/(pivotCacheDefinition\d+)[.]xml[.]rels/);
+                            if (match) {
+                                await this._processPivotCacheDefinitionRelsEntry(stream, model, match[1]);
+                                break;
+                            }
+                            match = entryName.match(/xl\/pivotCache\/(pivotCacheRecords\d+)[.]xml/);
+                            if (match) {
+                                await this._processPivotCacheRecordsEntry(stream, model, match[1]);
+                                break;
+                            }
                         }
                     }
                 }
@@ -515,21 +715,24 @@ class XLSX {
                 Target: "sharedStrings.xml"
             });
         }
-        if ((model.pivotTables || []).length) {
-            const pivotTable = model.pivotTables[0];
+        // Add relationships for all pivot tables
+        (model.pivotTables || []).forEach((pivotTable) => {
             pivotTable.rId = `rId${count++}`;
             relationships.push({
                 Id: pivotTable.rId,
                 Type: XLSX.RelType.PivotCacheDefinition,
-                Target: "pivotCache/pivotCacheDefinition1.xml"
+                Target: `pivotCache/pivotCacheDefinition${pivotTable.tableNumber}.xml`
             });
-        }
-        model.worksheets.forEach((worksheet) => {
+        });
+        model.worksheets.forEach((worksheet, index) => {
+            // Use sequential index (1-based) for file naming, not worksheet.id (sheetId)
+            // sheetId can be non-sequential (e.g., 1, 3, 5) which would create gaps in filenames
             worksheet.rId = `rId${count++}`;
+            worksheet.fileIndex = index + 1; // Store for use in addWorksheets and content types
             relationships.push({
                 Id: worksheet.rId,
                 Type: XLSX.RelType.Worksheet,
-                Target: `worksheets/sheet${worksheet.id}.xml`
+                Target: `worksheets/sheet${worksheet.fileIndex}.xml`
             });
         });
         const xform = new RelationshipsXform();
@@ -558,22 +761,24 @@ class XLSX {
         const commentsXform = new CommentsXform();
         const vmlNotesXform = new VmlNotesXform();
         // write sheets
-        model.worksheets.forEach((worksheet) => {
+        model.worksheets.forEach((worksheet, index) => {
+            // Use fileIndex if set by addWorkbookRels, otherwise use index + 1
+            const fileIndex = worksheet.fileIndex || index + 1;
             let xmlStream = new XmlStream();
             worksheetXform.render(xmlStream, worksheet);
-            zip.append(xmlStream.xml, { name: `xl/worksheets/sheet${worksheet.id}.xml` });
+            zip.append(xmlStream.xml, { name: `xl/worksheets/sheet${fileIndex}.xml` });
             if (worksheet.rels && worksheet.rels.length) {
                 xmlStream = new XmlStream();
                 relationshipsXform.render(xmlStream, worksheet.rels);
-                zip.append(xmlStream.xml, { name: `xl/worksheets/_rels/sheet${worksheet.id}.xml.rels` });
+                zip.append(xmlStream.xml, { name: `xl/worksheets/_rels/sheet${fileIndex}.xml.rels` });
             }
             if (worksheet.comments.length > 0) {
                 xmlStream = new XmlStream();
                 commentsXform.render(xmlStream, worksheet);
-                zip.append(xmlStream.xml, { name: `xl/comments${worksheet.id}.xml` });
+                zip.append(xmlStream.xml, { name: `xl/comments${fileIndex}.xml` });
                 xmlStream = new XmlStream();
                 vmlNotesXform.render(xmlStream, worksheet);
-                zip.append(xmlStream.xml, { name: `xl/drawings/vmlDrawing${worksheet.id}.vml` });
+                zip.append(xmlStream.xml, { name: `xl/drawings/vmlDrawing${fileIndex}.vml` });
             }
         });
     }
@@ -626,37 +831,55 @@ class XLSX {
         if (!model.pivotTables.length) {
             return;
         }
-        const pivotTable = model.pivotTables[0];
         const pivotCacheRecordsXform = new PivotCacheRecordsXform();
         const pivotCacheDefinitionXform = new PivotCacheDefinitionXform();
         const pivotTableXform = new PivotTableXform();
         const relsXform = new RelationshipsXform();
-        // pivot cache records
-        let xml = pivotCacheRecordsXform.toXml(pivotTable);
-        zip.append(xml, { name: "xl/pivotCache/pivotCacheRecords1.xml" });
-        // pivot cache definition
-        xml = pivotCacheDefinitionXform.toXml(pivotTable);
-        zip.append(xml, { name: "xl/pivotCache/pivotCacheDefinition1.xml" });
-        // pivot cache definition rels
-        xml = relsXform.toXml([
-            {
-                Id: "rId1",
-                Type: XLSX.RelType.PivotCacheRecords,
-                Target: "pivotCacheRecords1.xml"
+        // Generate files for each pivot table
+        model.pivotTables.forEach((pivotTable) => {
+            const n = pivotTable.tableNumber;
+            // For loaded pivot tables, use the stored cache data
+            // For new pivot tables, use the source data
+            const isLoaded = pivotTable.isLoaded;
+            if (isLoaded) {
+                // Loaded pivot table - use stored cache definition and records
+                if (pivotTable.cacheDefinition) {
+                    const xml = pivotCacheDefinitionXform.toXml(pivotTable.cacheDefinition);
+                    zip.append(xml, { name: `xl/pivotCache/pivotCacheDefinition${n}.xml` });
+                }
+                if (pivotTable.cacheRecords) {
+                    const xml = pivotCacheRecordsXform.toXml(pivotTable.cacheRecords);
+                    zip.append(xml, { name: `xl/pivotCache/pivotCacheRecords${n}.xml` });
+                }
             }
-        ]);
-        zip.append(xml, { name: "xl/pivotCache/_rels/pivotCacheDefinition1.xml.rels" });
-        // pivot table
-        xml = pivotTableXform.toXml(pivotTable);
-        zip.append(xml, { name: "xl/pivotTables/pivotTable1.xml" });
-        xml = relsXform.toXml([
-            {
-                Id: "rId1",
-                Type: XLSX.RelType.PivotCacheDefinition,
-                Target: "../pivotCache/pivotCacheDefinition1.xml"
+            else {
+                // New pivot table - generate from source
+                let xml = pivotCacheRecordsXform.toXml(pivotTable);
+                zip.append(xml, { name: `xl/pivotCache/pivotCacheRecords${n}.xml` });
+                xml = pivotCacheDefinitionXform.toXml(pivotTable);
+                zip.append(xml, { name: `xl/pivotCache/pivotCacheDefinition${n}.xml` });
             }
-        ]);
-        zip.append(xml, { name: "xl/pivotTables/_rels/pivotTable1.xml.rels" });
+            // pivot cache definition rels (same for both)
+            let xml = relsXform.toXml([
+                {
+                    Id: "rId1",
+                    Type: XLSX.RelType.PivotCacheRecords,
+                    Target: `pivotCacheRecords${n}.xml`
+                }
+            ]);
+            zip.append(xml, { name: `xl/pivotCache/_rels/pivotCacheDefinition${n}.xml.rels` });
+            // pivot table
+            xml = pivotTableXform.toXml(pivotTable);
+            zip.append(xml, { name: `xl/pivotTables/pivotTable${n}.xml` });
+            xml = relsXform.toXml([
+                {
+                    Id: "rId1",
+                    Type: XLSX.RelType.PivotCacheDefinition,
+                    Target: `../pivotCache/pivotCacheDefinition${n}.xml`
+                }
+            ]);
+            zip.append(xml, { name: `xl/pivotTables/_rels/pivotTable${n}.xml.rels` });
+        });
     }
     _finalize(zip) {
         return new Promise((resolve, reject) => {

package/dist/types/doc/column.d.ts

@@ -1,8 +1,11 @@
 import type { Cell, CellValueType } from "./cell.js";
 import type { Worksheet } from "./worksheet.js";
-import type { Style, NumFmt, Font, Alignment, Protection, Borders, Fill } from "../types.js";
+import type { Style, NumFmt, Font, Alignment, Protection, Borders, Fill, CellValue } from "../types.js";
+/** Header value type - can be a single value or array for multi-row headers */
+export type ColumnHeaderValue = CellValue | CellValue[];
 export interface ColumnDefn {
-    header?: string | string[];
+    /** Column header value(s). Can be string, Date, number, or any CellValue type */
+    header?: ColumnHeaderValue;
     key?: string;
     width?: number;
     outlineLevel?: number;
@@ -45,12 +48,16 @@ declare class Column {
     get isCustomWidth(): boolean;
     get defn(): ColumnDefn;
     set defn(value: ColumnDefn | undefined);
-    get headers(): string[];
     /**
-     * Can be a string to set one row high header or an array to set multi-row high header
+     * Get header values as an array (for multi-row header support)
      */
-    get header(): string | string[] | undefined;
-    set header(value: string | string[] | undefined);
+    get headers(): CellValue[];
+    /**
+     * Can be a single value or an array for multi-row headers.
+     * Supports any CellValue type including Date, number, string, etc.
+     */
+    get header(): ColumnHeaderValue | undefined;
+    set header(value: ColumnHeaderValue | undefined);
     /**
      * The name of the properties associated with this column in each row
      */

package/dist/types/doc/pivot-table.d.ts

@@ -1,22 +1,148 @@
-interface PivotTableModel {
-    sourceSheet: any;
+import type { Table } from "./table.js";
+/**
+ * Interface representing the source data abstraction for pivot tables.
+ * This allows both Worksheet and Table to be used as pivot table data sources.
+ */
+export interface PivotTableSource {
+    /** Name of the source (worksheet name or table name) */
+    name: string;
+    /** Get row values by 1-indexed row number */
+    getRow(rowNumber: number): {
+        values: any[];
+    };
+    /** Get column values by 1-indexed column number */
+    getColumn(columnNumber: number): {
+        values: any[];
+    };
+    /** Get all sheet values as a sparse 2D array */
+    getSheetValues(): any[][];
+    /** Dimensions with short range reference (e.g., "A1:E10") */
+    dimensions: {
+        shortRange: string;
+    };
+}
+/**
+ * Model for creating a new pivot table.
+ * Pass this to worksheet.addPivotTable() to create a pivot table.
+ */
+export interface PivotTableModel {
+    /**
+     * Source worksheet for the pivot table data.
+     * Either sourceSheet or sourceTable must be provided (mutually exclusive).
+     */
+    sourceSheet?: PivotTableSource;
+    /**
+     * Source table for the pivot table data.
+     * Either sourceSheet or sourceTable must be provided (mutually exclusive).
+     * The table must have headerRow=true and contain at least one data row.
+     */
+    sourceTable?: Table;
+    /** Column names to use as row fields in the pivot table */
     rows: string[];
-    columns: string[];
+    /**
+     * Column names to use as column fields in the pivot table.
+     * If omitted or empty, Excel will use "Values" as the column field.
+     * @default []
+     */
+    columns?: string[];
+    /** Column names to aggregate as values in the pivot table */
     values: string[];
-    metric?: string;
+    /**
+     * Aggregation metric for the pivot table values.
+     * - 'sum': Sum of values (default)
+     * - 'count': Count of values
+     * @default 'sum'
+     */
+    metric?: "sum" | "count";
+    /**
+     * Controls whether pivot table style overrides worksheet column widths.
+     * - '0': Preserve worksheet column widths (useful for custom sizing)
+     * - '1': Apply pivot table style width/height (default Excel behavior)
+     * @default '1'
+     */
+    applyWidthHeightFormats?: "0" | "1";
 }
-interface CacheField {
+/**
+ * Represents a cache field in a pivot table.
+ * Cache fields store unique values from source columns for row/column grouping.
+ */
+export interface CacheField {
+    /** Name of the field (column header from source) */
     name: string;
+    /** Unique values for row/column fields, null for value fields */
     sharedItems: any[] | null;
 }
-interface PivotTable {
-    sourceSheet: any;
+/** Aggregation function types for pivot table data fields */
+export type PivotTableSubtotal = "sum" | "count" | "average" | "max" | "min" | "product" | "countNums" | "stdDev" | "stdDevP" | "var" | "varP";
+/**
+ * Data field configuration for pivot table aggregation.
+ * Defines how values are aggregated in the pivot table.
+ */
+export interface DataField {
+    /** Display name for the data field (e.g., "Sum of Sales") */
+    name: string;
+    /** Index of the source field in cacheFields */
+    fld: number;
+    /** Base field index for calculated fields */
+    baseField?: number;
+    /** Base item index for calculated fields */
+    baseItem?: number;
+    /** Aggregation function (default: 'sum') */
+    subtotal?: PivotTableSubtotal;
+}
+/**
+ * Internal pivot table representation used by the library.
+ * This is the processed model after calling makePivotTable().
+ */
+export interface PivotTable {
+    /** Source data adapter (always present for new pivot tables) */
+    source?: PivotTableSource;
+    /** Field indices for row fields */
     rows: number[];
+    /** Field indices for column fields */
     columns: number[];
+    /** Field indices for value fields */
     values: number[];
-    metric: string;
+    /** Aggregation metric */
+    metric: "sum" | "count";
+    /** Cache fields with shared items */
     cacheFields: CacheField[];
+    /** Cache ID for linking to pivot cache */
     cacheId: string;
+    /** Width/height format setting */
+    applyWidthHeightFormats: "0" | "1";
+    /** 1-indexed table number for file naming (pivotTable1.xml, pivotTable2.xml, etc.) */
+    tableNumber: number;
+    /** Flag indicating this pivot table was loaded from file (not newly created) */
+    isLoaded?: boolean;
+    /** Data fields for loaded pivot tables */
+    dataFields?: DataField[];
+    /** Cache definition for loaded pivot tables */
+    cacheDefinition?: ParsedCacheDefinition;
+    /** Cache records for loaded pivot tables */
+    cacheRecords?: ParsedCacheRecords;
+}
+/**
+ * Parsed cache definition from loaded pivot table files.
+ */
+export interface ParsedCacheDefinition {
+    sourceRef?: string;
+    sourceSheet?: string;
+    cacheFields: CacheField[];
+    recordCount?: number;
+    rId?: string;
+    isLoaded?: boolean;
+}
+/**
+ * Parsed cache records from loaded pivot table files.
+ */
+export interface ParsedCacheRecords {
+    records: Array<Array<{
+        type: string;
+        value?: any;
+    }>>;
+    count: number;
+    isLoaded?: boolean;
 }
 declare function makePivotTable(worksheet: any, model: PivotTableModel): PivotTable;
-export { makePivotTable, type PivotTable, type PivotTableModel };
+export { makePivotTable };

package/dist/types/doc/workbook.d.ts

@@ -36,6 +36,8 @@ interface WorkbookModel {
     themes?: unknown;
     media: WorkbookMedia[];
     pivotTables: PivotTable[];
+    /** Loaded pivot tables from file - used during reconciliation */
+    loadedPivotTables?: any[];
     calcProperties: Partial<CalculationProperties>;
 }
 declare class Workbook {

package/dist/types/index.d.ts

@@ -13,6 +13,7 @@ export { Image } from "./doc/image.js";
 export * from "./doc/anchor.js";
 export { Table } from "./doc/table.js";
 export { DataValidations } from "./doc/data-validations.js";
+export type { PivotTable, PivotTableModel, PivotTableSource, CacheField, DataField, PivotTableSubtotal, ParsedCacheDefinition, ParsedCacheRecords } from "./doc/pivot-table.js";
 export * from "./doc/enums.js";
 export * from "./types.js";
 export * from "./utils/sheet-utils.js";

package/dist/types/xlsx/xform/pivot-table/cache-field-xform.d.ts

@@ -0,0 +1,42 @@
+import { BaseXform } from "../base-xform.js";
+/**
+ * Parsed cache field model containing name and shared items (if any)
+ */
+interface CacheFieldModel {
+    name: string;
+    sharedItems: string[] | null;
+    containsNumber?: boolean;
+    containsInteger?: boolean;
+    minValue?: number;
+    maxValue?: number;
+}
+/**
+ * Xform for parsing individual <cacheField> elements within a pivot cache definition.
+ *
+ * Example XML:
+ * ```xml
+ * <cacheField name="Category" numFmtId="0">
+ *   <sharedItems count="3">
+ *     <s v="A" />
+ *     <s v="B" />
+ *     <s v="C" />
+ *   </sharedItems>
+ * </cacheField>
+ *
+ * <cacheField name="Value" numFmtId="0">
+ *   <sharedItems containsSemiMixedTypes="0" containsString="0"
+ *                containsNumber="1" containsInteger="1" minValue="5" maxValue="45" />
+ * </cacheField>
+ * ```
+ */
+declare class CacheFieldXform extends BaseXform {
+    model: CacheFieldModel | null;
+    private inSharedItems;
+    constructor();
+    get tag(): string;
+    reset(): void;
+    parseOpen(node: any): boolean;
+    parseText(_text: string): void;
+    parseClose(name: string): boolean;
+}
+export { CacheFieldXform, type CacheFieldModel };