@cj-tech-master/excelts 5.0.6 → 5.1.0

package/dist/browser/modules/excel/xlsx/xform/pivot-table/cache-field-xform.js

@@ -1,5 +1,9 @@
 import { BaseXform } from "../base-xform.js";
-import { xmlDecode } from "../../../../../utils/utils.browser.js";
+import { PivotErrorValue } from "../../../pivot-table.js";
+import { parseOoxmlDate } from "../../../../../utils/utils.browser.js";
+import { RawXmlCollector } from "./raw-xml-collector.js";
+/** Attribute keys on <cacheField> that are individually parsed (not collected into extraAttrs). */
+const KNOWN_CACHE_FIELD_KEYS = new Set(["name", "numFmtId"]);
 /**
  * Xform for parsing individual <cacheField> elements within a pivot cache definition.
  *
@@ -22,8 +26,9 @@ import { xmlDecode } from "../../../../../utils/utils.browser.js";
 class CacheFieldXform extends BaseXform {
     constructor() {
         super();
-        this.model = null;
         this.inSharedItems = false;
+        this.fieldGroupCollector = new RawXmlCollector("fieldGroup");
+        this.model = null;
     }
     get tag() {
         return "cacheField";
@@ -31,89 +36,123 @@ class CacheFieldXform extends BaseXform {
     reset() {
         this.model = null;
         this.inSharedItems = false;
+        this.fieldGroupCollector.reset();
     }
     parseOpen(node) {
         const { name, attributes } = node;
+        // Collect fieldGroup XML verbatim for roundtrip preservation
+        if (this.fieldGroupCollector.active) {
+            this.fieldGroupCollector.feedOpen(name, attributes);
+            return true;
+        }
         switch (name) {
-            case "cacheField":
+            case "cacheField": {
                 // Initialize the model with field name
+                // Collect unknown attributes into extraAttrs bag for roundtrip preservation
+                const extraAttrs = {};
+                for (const [k, v] of Object.entries(attributes)) {
+                    if (!KNOWN_CACHE_FIELD_KEYS.has(k)) {
+                        extraAttrs[k] = String(v);
+                    }
+                }
                 this.model = {
-                    name: xmlDecode(attributes.name || ""),
-                    sharedItems: null
+                    name: attributes.name ?? "",
+                    sharedItems: null,
+                    numFmtId: attributes.numFmtId,
+                    isLoaded: true,
+                    extraAttrs: Object.keys(extraAttrs).length > 0 ? extraAttrs : undefined
                 };
                 break;
+            }
+            case "fieldGroup":
+                // Start collecting fieldGroup XML for roundtrip preservation
+                if (this.model) {
+                    this.fieldGroupCollector.start(attributes);
+                }
+                break;
             case "sharedItems":
                 this.inSharedItems = true;
                 // Store numeric field metadata
                 if (this.model) {
-                    this.model.containsNumber = attributes.containsNumber === "1";
-                    this.model.containsInteger = attributes.containsInteger === "1";
+                    // R8-B4: Store containsNumber/containsInteger as raw strings for roundtrip fidelity.
+                    // Previously "0" was lost because it was parsed as undefined.
+                    if (attributes.containsNumber !== undefined) {
+                        this.model.containsNumber = attributes.containsNumber;
+                    }
+                    if (attributes.containsInteger !== undefined) {
+                        this.model.containsInteger = attributes.containsInteger;
+                    }
+                    // R8-B7: Guard against NaN from malformed minValue/maxValue
                     if (attributes.minValue !== undefined) {
-                        this.model.minValue = parseFloat(attributes.minValue);
+                        const parsed = parseFloat(attributes.minValue);
+                        if (Number.isFinite(parsed)) {
+                            this.model.minValue = parsed;
+                        }
                     }
                     if (attributes.maxValue !== undefined) {
-                        this.model.maxValue = parseFloat(attributes.maxValue);
+                        const parsed = parseFloat(attributes.maxValue);
+                        if (Number.isFinite(parsed)) {
+                            this.model.maxValue = parsed;
+                        }
+                    }
+                    // Preserve original sharedItems type attributes for roundtrip fidelity.
+                    // These are stored as raw strings so we can re-emit them exactly as loaded.
+                    if (attributes.containsSemiMixedTypes !== undefined) {
+                        this.model.containsSemiMixedTypes = attributes.containsSemiMixedTypes;
+                    }
+                    if (attributes.containsNonDate !== undefined) {
+                        this.model.containsNonDate = attributes.containsNonDate;
+                    }
+                    if (attributes.containsString !== undefined) {
+                        this.model.containsString = attributes.containsString;
                     }
-                    // Initialize sharedItems array if count > 0 (for both string and numeric fields)
-                    const count = parseInt(attributes.count || "0", 10);
-                    if (count > 0) {
-                        this.model.sharedItems = [];
+                    if (attributes.containsBlank !== undefined) {
+                        this.model.containsBlank = attributes.containsBlank;
                     }
-                    else {
-                        // No count means no individual items (pure numeric field)
-                        this.model.sharedItems = null;
+                    if (attributes.containsDate !== undefined) {
+                        this.model.containsDate = attributes.containsDate;
                     }
+                    if (attributes.containsMixedTypes !== undefined) {
+                        this.model.containsMixedTypes = attributes.containsMixedTypes;
+                    }
+                    // Initialize sharedItems array when sharedItems element is present.
+                    // count="0" means an explicitly empty shared items list (not the same as absent).
+                    // No count attribute also gets an empty array since the <sharedItems> element
+                    // itself is present — child elements (<s>, <n>, etc.) will be pushed into it.
+                    this.model.sharedItems = [];
                 }
                 break;
             case "s":
-                // String value in sharedItems
-                if (this.inSharedItems && this.model?.sharedItems !== null) {
-                    // Decode XML entities in the value
-                    const value = xmlDecode(attributes.v || "");
-                    this.model.sharedItems.push(value);
-                }
-                break;
             case "n":
-                // Numeric value in sharedItems (less common, but possible)
-                if (this.inSharedItems && this.model?.sharedItems !== null) {
-                    const value = parseFloat(attributes.v || "0");
-                    this.model.sharedItems.push(value);
-                }
-                break;
             case "b":
-                // Boolean value in sharedItems
-                if (this.inSharedItems && this.model?.sharedItems !== null) {
-                    const value = attributes.v === "1";
-                    this.model.sharedItems.push(value);
-                }
-                break;
             case "e":
-                // Error value in sharedItems
-                if (this.inSharedItems && this.model?.sharedItems !== null) {
-                    const value = `#${attributes.v || "ERROR!"}`;
-                    this.model.sharedItems.push(value);
-                }
-                break;
             case "m":
-                // Missing/null value in sharedItems
-                if (this.inSharedItems && this.model?.sharedItems !== null) {
-                    this.model.sharedItems.push(null);
-                }
-                break;
             case "d":
-                // Date value in sharedItems
-                if (this.inSharedItems && this.model?.sharedItems !== null) {
-                    const value = new Date(attributes.v || "");
-                    this.model.sharedItems.push(value);
+                // Shared item value — push to sharedItems array if we're inside <sharedItems>
+                if (this.inSharedItems && this.model && this.model.sharedItems !== null) {
+                    this.model.sharedItems.push(parseSharedItemValue(name, attributes));
                 }
                 break;
         }
         return true;
     }
-    parseText(_text) {
-        // No text content in cacheField elements
+    parseText(text) {
+        // Forward text to active collector (B3 fix: text nodes in fieldGroup)
+        if (this.fieldGroupCollector.active) {
+            this.fieldGroupCollector.feedText(text);
+        }
     }
     parseClose(name) {
+        // Handle fieldGroup collection — close tags
+        if (this.fieldGroupCollector.active) {
+            if (this.fieldGroupCollector.feedClose(name)) {
+                if (this.model) {
+                    this.model.fieldGroupXml = this.fieldGroupCollector.result;
+                }
+                this.fieldGroupCollector.reset();
+            }
+            return true;
+        }
         switch (name) {
             case "cacheField":
                 // End of this cacheField element
@@ -125,4 +164,47 @@ class CacheFieldXform extends BaseXform {
         return true;
     }
 }
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Convert a SAX-parsed shared item element into its typed value.
+ *
+ * Tag mapping:
+ * - `s` → string
+ * - `n` → number
+ * - `b` → boolean
+ * - `e` → PivotErrorValue
+ * - `m` → null (missing)
+ * - `d` → Date (UTC)
+ */
+function parseSharedItemValue(tag, attributes) {
+    switch (tag) {
+        case "s":
+            return attributes.v ?? "";
+        case "n":
+            // Missing v attribute → treat as null (missing) rather than fabricating 0
+            if (attributes.v === undefined || attributes.v === "") {
+                return null;
+            }
+            return parseFloat(attributes.v);
+        case "b":
+            return attributes.v === "1";
+        case "e":
+            return new PivotErrorValue(attributes.v ?? "");
+        case "m":
+            return null;
+        case "d": {
+            // Missing/empty v attribute → treat as missing value (null) to avoid Invalid Date
+            if (!attributes.v) {
+                return null;
+            }
+            // R8-B13: Guard against Invalid Date from malformed date strings
+            const date = parseOoxmlDate(attributes.v);
+            return isNaN(date.getTime()) ? null : date;
+        }
+        default:
+            return null;
+    }
+}
 export { CacheFieldXform };

package/dist/browser/modules/excel/xlsx/xform/pivot-table/cache-field.d.ts

@@ -1,15 +1,14 @@
-interface CacheFieldConfig {
-    name: string;
-    sharedItems: any[] | null;
-    minValue?: number;
-    maxValue?: number;
-}
-declare class CacheField {
-    private name;
-    private sharedItems;
-    private minValue?;
-    private maxValue?;
-    constructor({ name, sharedItems, minValue, maxValue }: CacheFieldConfig);
-    render(): string;
-}
-export { CacheField };
+import type { CacheField as CacheFieldType } from "@excel/pivot-table";
+/**
+ * Format a Date for OOXML pivot cache output.
+ * Excel expects `"2024-01-15T00:00:00"` — no milliseconds, no trailing "Z".
+ */
+declare function formatDateForExcel(date: Date): string;
+/**
+ * Render a single `<cacheField>` element as an XML string.
+ *
+ * This is a pure data-in → string-out transformation with no state or lifecycle,
+ * so it is a plain function rather than a class.
+ */
+declare function renderCacheField(cf: CacheFieldType): string;
+export { renderCacheField, formatDateForExcel };

package/dist/browser/modules/excel/xlsx/xform/pivot-table/cache-field.js

@@ -1,78 +1,252 @@
 import { xmlEncode } from "../../../../../utils/utils.browser.js";
-class CacheField {
-    constructor({ name, sharedItems, minValue, maxValue }) {
-        // string type
-        //
-        // {
-        //   'name': 'A',
-        //   'sharedItems': ['a1', 'a2', 'a3']
-        // }
-        //
-        // or
-        //
-        // integer type (no sharedItems)
-        //
-        // {
-        //   'name': 'D',
-        //   'sharedItems': null,
-        //   'minValue': 5,
-        //   'maxValue': 45
-        // }
-        //
-        // or
-        //
-        // numeric type with shared items (used as both row/column and value field)
-        //
-        // {
-        //   'name': 'C',
-        //   'sharedItems': [5, 24, 35, 45]
-        // }
-        this.name = name;
-        this.sharedItems = sharedItems;
-        this.minValue = minValue;
-        this.maxValue = maxValue;
-    }
-    render() {
-        // PivotCache Field: http://www.datypic.com/sc/ooxml/e-ssml_cacheField-1.html
-        // Shared Items: http://www.datypic.com/sc/ooxml/e-ssml_sharedItems-1.html
-        // Escape XML special characters in name attribute
-        const escapedName = xmlEncode(this.name);
-        // No shared items - field not used for rows/columns
-        if (this.sharedItems === null) {
-            // If no minValue/maxValue, this is an unused field - use empty sharedItems like Excel does
-            if (this.minValue === undefined || this.maxValue === undefined) {
-                return `<cacheField name="${escapedName}" numFmtId="0">
-      <sharedItems />
-    </cacheField>`;
+import { PivotErrorValue } from "../../../pivot-table.js";
+/**
+ * Format a Date for OOXML pivot cache output.
+ * Excel expects `"2024-01-15T00:00:00"` — no milliseconds, no trailing "Z".
+ */
+function formatDateForExcel(date) {
+    // Guard against Invalid Date — toISOString() throws RangeError for invalid dates
+    if (isNaN(date.getTime())) {
+        return "";
+    }
+    return date.toISOString().replace(/\.\d{3}Z$/, "");
+}
+/**
+ * Render a single `<cacheField>` element as an XML string.
+ *
+ * This is a pure data-in → string-out transformation with no state or lifecycle,
+ * so it is a plain function rather than a class.
+ */
+function renderCacheField(cf) {
+    // PivotCache Field: http://www.datypic.com/sc/ooxml/e-ssml_cacheField-1.html
+    // Shared Items: http://www.datypic.com/sc/ooxml/e-ssml_sharedItems-1.html
+    // Escape XML special characters in name attribute
+    const escapedName = xmlEncode(cf.name);
+    const fmtId = cf.numFmtId ?? "0";
+    // Extra unknown attributes for roundtrip preservation (e.g. caption, formula)
+    const extraStr = buildExtraAttrsStr(cf.extraAttrs);
+    // fieldGroup raw XML for roundtrip (rendered after sharedItems per OOXML schema)
+    const fgXml = cf.fieldGroupXml ? `\n      ${cf.fieldGroupXml}` : "";
+    // --- Branch A: no shared-item children ---
+    // For loaded fields, only render <sharedItems> if it was present in the original (sharedItems !== null).
+    // For new fields, sharedItems === null means a value-only field that still needs <sharedItems />.
+    if (cf.sharedItems === null) {
+        if (cf.isLoaded) {
+            // Loaded field with no <sharedItems> element — don't add one on roundtrip
+            if (fgXml) {
+                // Has fieldGroup — need open/close tags to wrap it
+                return `<cacheField name="${escapedName}" numFmtId="${fmtId}"${extraStr}>${fgXml}\n    </cacheField>`;
             }
-            // Numeric field used only for values (not rows/columns) - include min/max
-            return `<cacheField name="${escapedName}" numFmtId="0">
-      <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1" containsInteger="1" minValue="${this.minValue}" maxValue="${this.maxValue}" />
-    </cacheField>`;
+            // R8-B6: No children at all — use self-closing tag to avoid whitespace content
+            return `<cacheField name="${escapedName}" numFmtId="${fmtId}"${extraStr} />`;
+        }
+        // New field — render bare empty <sharedItems />
+        let attrStr;
+        if (cf.minValue !== undefined && cf.maxValue !== undefined) {
+            // New numeric-only field (no row/column usage) – compute type attributes
+            const integerAttr = cf.containsInteger ? ' containsInteger="1"' : "";
+            attrStr = ` containsSemiMixedTypes="0" containsString="0" containsNumber="1"${integerAttr} minValue="${cf.minValue}" maxValue="${cf.maxValue}"`;
+        }
+        else {
+            attrStr = "";
         }
-        // Shared items exist - check if all values are numeric
-        // Note: empty array returns true for every(), so check length first
-        const allNumeric = this.sharedItems.length > 0 &&
-            this.sharedItems.every(item => typeof item === "number" && Number.isFinite(item));
-        const allInteger = allNumeric && this.sharedItems.every(item => Number.isInteger(item));
-        if (allNumeric) {
-            // Numeric shared items - used when field is both a row/column field AND a value field
-            // This allows Excel to both group by unique values AND perform aggregation
-            const minValue = Math.min(...this.sharedItems);
-            const maxValue = Math.max(...this.sharedItems);
-            const integerAttr = allInteger ? ' containsInteger="1"' : "";
-            return `<cacheField name="${escapedName}" numFmtId="0">
-      <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1"${integerAttr} minValue="${minValue}" maxValue="${maxValue}" count="${this.sharedItems.length}">
-        ${this.sharedItems.map(item => `<n v="${item}" />`).join("")}
-      </sharedItems>
+        return `<cacheField name="${escapedName}" numFmtId="${fmtId}"${extraStr}>
+      <sharedItems${attrStr} />${fgXml}
     </cacheField>`;
+    }
+    if (cf.isLoaded && cf.sharedItems.length === 0) {
+        // Roundtrip: use preserved attributes exactly as parsed
+        const attrStr = buildLoadedSharedItemsAttrs(cf);
+        return `<cacheField name="${escapedName}" numFmtId="${fmtId}"${extraStr}>
+      <sharedItems${attrStr} />${fgXml}
+    </cacheField>`;
+    }
+    // --- Branch B: shared items present – render each child element ---
+    // For loaded fields, skip recomputation – use preserved attributes directly
+    if (cf.isLoaded) {
+        const itemXmls = renderSharedItemElements(cf.sharedItems);
+        const finalAttrStr = buildLoadedSharedItemsAttrs(cf);
+        return `<cacheField name="${escapedName}" numFmtId="${fmtId}"${extraStr}>
+      <sharedItems${finalAttrStr} count="${cf.sharedItems.length}">
+        ${itemXmls}
+      </sharedItems>${fgXml}
+    </cacheField>`;
+    }
+    // New field – analyze content types in a single pass (avoids stack overflow from spread on large arrays)
+    let hasString = false;
+    let hasNumber = false;
+    let hasBoolean = false;
+    let hasDate = false;
+    let hasNull = false;
+    let hasError = false;
+    let allInteger = true;
+    let minValue = Infinity;
+    let maxValue = -Infinity;
+    for (const item of cf.sharedItems) {
+        if (item === null) {
+            hasNull = true;
+        }
+        else if (item instanceof PivotErrorValue) {
+            hasError = true;
         }
-        // String shared items - escape XML special characters in each value
-        return `<cacheField name="${escapedName}" numFmtId="0">
-      <sharedItems count="${this.sharedItems.length}">
-        ${this.sharedItems.map(item => `<s v="${xmlEncode(String(item))}" />`).join("")}
-      </sharedItems>
+        else if (typeof item === "string") {
+            hasString = true;
+        }
+        else if (typeof item === "number") {
+            if (Number.isFinite(item)) {
+                hasNumber = true;
+                if (item < minValue) {
+                    minValue = item;
+                }
+                if (item > maxValue) {
+                    maxValue = item;
+                }
+                if (!Number.isInteger(item)) {
+                    allInteger = false;
+                }
+            }
+            else {
+                // NaN, Infinity, -Infinity are not valid OOXML numeric values — treat as missing
+                hasNull = true;
+            }
+        }
+        else if (typeof item === "boolean") {
+            hasBoolean = true;
+        }
+        else if (item instanceof Date) {
+            hasDate = true;
+        }
+    }
+    // Build sharedItems attributes per OOXML spec:
+    // - containsSemiMixedTypes: "0" if no strings at all (default "1")
+    // - containsString: "0" if no string items (default "1")
+    // - containsNumber: "1" if any numeric items (default "0")
+    // - containsInteger: "1" if all numbers are integers (only when containsNumber="1")
+    // - containsBlank: "1" if any null/missing items
+    // - containsMixedTypes: "1" if multiple non-string types present
+    // - containsDate: "1" if any date items (default "0")
+    const attrs = [];
+    if (!hasString) {
+        // No string items at all (errors, numbers, booleans, dates, nulls are all non-string)
+        attrs.push('containsSemiMixedTypes="0"');
+        attrs.push('containsString="0"');
+    }
+    // containsMixedTypes: set when multiple distinct non-string type families are present
+    // e.g., number+date, string+number, error+number, etc.
+    const typeCount = (hasString ? 1 : 0) +
+        (hasNumber ? 1 : 0) +
+        (hasBoolean ? 1 : 0) +
+        (hasDate ? 1 : 0) +
+        (hasError ? 1 : 0);
+    if (typeCount > 1) {
+        attrs.push('containsMixedTypes="1"');
+    }
+    if (hasNumber) {
+        attrs.push('containsNumber="1"');
+        if (allInteger) {
+            attrs.push('containsInteger="1"');
+        }
+        attrs.push(`minValue="${minValue}"`);
+        attrs.push(`maxValue="${maxValue}"`);
+    }
+    if (hasDate) {
+        attrs.push('containsDate="1"');
+    }
+    if (hasNull) {
+        attrs.push('containsBlank="1"');
+    }
+    const itemXmls = renderSharedItemElements(cf.sharedItems);
+    const attrStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+    return `<cacheField name="${escapedName}" numFmtId="${fmtId}"${extraStr}>
+      <sharedItems${attrStr} count="${cf.sharedItems.length}">
+        ${itemXmls}
+      </sharedItems>${fgXml}
     </cacheField>`;
+}
+/**
+ * Render shared item elements as an XML string.
+ */
+function renderSharedItemElements(sharedItems) {
+    const itemXmls = [];
+    for (const item of sharedItems) {
+        if (item === null) {
+            itemXmls.push("<m />");
+        }
+        else if (item instanceof PivotErrorValue) {
+            itemXmls.push(`<e v="${xmlEncode(item.code)}" />`);
+        }
+        else if (typeof item === "number") {
+            if (Number.isFinite(item)) {
+                itemXmls.push(`<n v="${item}" />`);
+            }
+            else {
+                // NaN, Infinity, -Infinity — not valid in OOXML, render as missing
+                itemXmls.push("<m />");
+            }
+        }
+        else if (typeof item === "boolean") {
+            itemXmls.push(`<b v="${item ? "1" : "0"}" />`);
+        }
+        else if (item instanceof Date) {
+            itemXmls.push(`<d v="${formatDateForExcel(item)}" />`);
+        }
+        else {
+            // string
+            itemXmls.push(`<s v="${xmlEncode(item)}" />`);
+        }
+    }
+    return itemXmls.join("");
+}
+/**
+ * Build extra attributes string for cacheField element (roundtrip preservation).
+ */
+function buildExtraAttrsStr(extraAttrs) {
+    if (!extraAttrs) {
+        return "";
+    }
+    return Object.entries(extraAttrs)
+        .map(([k, v]) => ` ${k}="${xmlEncode(v)}"`)
+        .join("");
+}
+/**
+ * Build sharedItems attribute string from preserved loaded attributes.
+ * Reconstructs the original attribute order for roundtrip fidelity.
+ */
+function buildLoadedSharedItemsAttrs(cf) {
+    const parts = [];
+    if (cf.containsSemiMixedTypes !== undefined) {
+        parts.push(`containsSemiMixedTypes="${cf.containsSemiMixedTypes}"`);
+    }
+    if (cf.containsNonDate !== undefined) {
+        parts.push(`containsNonDate="${cf.containsNonDate}"`);
+    }
+    if (cf.containsString !== undefined) {
+        parts.push(`containsString="${cf.containsString}"`);
+    }
+    if (cf.containsBlank !== undefined) {
+        parts.push(`containsBlank="${cf.containsBlank}"`);
+    }
+    if (cf.containsMixedTypes !== undefined) {
+        parts.push(`containsMixedTypes="${cf.containsMixedTypes}"`);
+    }
+    // R8-B4: containsNumber/containsInteger are now raw strings ("0"/"1") for roundtrip fidelity
+    if (cf.containsNumber !== undefined) {
+        parts.push(`containsNumber="${cf.containsNumber}"`);
+    }
+    if (cf.containsInteger !== undefined) {
+        parts.push(`containsInteger="${cf.containsInteger}"`);
+    }
+    // R8-B5: Emit minValue/maxValue independently of containsNumber — the original XML
+    // may have these attributes even without containsNumber="1"
+    if (cf.minValue !== undefined) {
+        parts.push(`minValue="${cf.minValue}"`);
+    }
+    if (cf.maxValue !== undefined) {
+        parts.push(`maxValue="${cf.maxValue}"`);
+    }
+    if (cf.containsDate !== undefined) {
+        parts.push(`containsDate="${cf.containsDate}"`);
     }
+    return parts.length > 0 ? ` ${parts.join(" ")}` : "";
 }
-export { CacheField };
+export { renderCacheField, formatDateForExcel };

package/dist/browser/modules/excel/xlsx/xform/pivot-table/pivot-cache-definition-xform.d.ts

@@ -1,46 +1,30 @@
 import { BaseXform } from "@excel/xlsx/xform/base-xform";
-import { type CacheFieldModel } from "@excel/xlsx/xform/pivot-table/cache-field-xform";
-import type { PivotTableSource } from "@excel/pivot-table";
-/**
- * Model for parsed pivot cache definition
- */
-interface ParsedCacheDefinitionModel {
-    sourceRef?: string;
-    sourceSheet?: string;
-    sourceTableName?: string;
-    cacheFields: CacheFieldModel[];
-    recordCount?: number;
-    rId?: string;
-    refreshOnLoad?: string;
-    createdVersion?: string;
-    refreshedVersion?: string;
-    minRefreshableVersion?: string;
-    isLoaded?: boolean;
-}
+import type { CacheField as CacheFieldType, ParsedCacheDefinition, PivotTableSource } from "@excel/pivot-table";
+import { XmlStream } from "@excel/utils/xml-stream";
 /**
  * Model for generating pivot cache definition (with live source)
  */
 interface CacheDefinitionModel {
     source: PivotTableSource;
-    cacheFields: any[];
+    cacheFields: CacheFieldType[];
 }
-declare class PivotCacheDefinitionXform extends BaseXform {
-    map: {
-        [key: string]: any;
-    };
-    model: ParsedCacheDefinitionModel | null;
+declare class PivotCacheDefinitionXform extends BaseXform<ParsedCacheDefinition | null> {
     private currentCacheField;
     private inCacheFields;
     private inCacheSource;
+    private extLstCollector;
+    private unknownCollector;
+    private unknownElementsXmlParts;
+    private cacheSourceChildCollector;
+    private cacheSourceXmlParts;
     constructor();
-    prepare(_model: any): void;
     get tag(): string;
     reset(): void;
     /**
      * Render pivot cache definition XML.
      * Supports both newly created models (with PivotTableSource) and loaded models.
      */
-    render(xmlStream: any, model: CacheDefinitionModel | ParsedCacheDefinitionModel): void;
+    render(xmlStream: XmlStream, model: CacheDefinitionModel | ParsedCacheDefinition): void;
     /**
      * Render newly created pivot cache definition
      */
@@ -52,10 +36,10 @@ declare class PivotCacheDefinitionXform extends BaseXform {
     parseOpen(node: any): boolean;
     parseText(text: string): void;
     parseClose(name: string): boolean;
-    reconcile(_model: any, _options: any): void;
-    static PIVOT_CACHE_DEFINITION_ATTRIBUTES: {
+    static renderCacheFieldsXml(cacheFields: CacheFieldType[]): string;
+    static readonly PIVOT_CACHE_DEFINITION_ATTRIBUTES: {
         xmlns: string;
         "xmlns:r": string;
     };
 }
-export { PivotCacheDefinitionXform, type ParsedCacheDefinitionModel };
+export { PivotCacheDefinitionXform };