@office-open/core 0.9.7 → 0.10.0

package/dist/{index-DMw7eid7.d.mts → index-BEQ12eyX.d.mts}

@@ -1,4 +1,4 @@
-import { c as CustomDescriptor } from "./index-C4r2WLEy.mjs";
+import { _ as CustomDescriptor } from "./index-L82O3q6V.mjs";
 
 //#region src/chart/chart-collection.d.ts
 /**
@@ -27,10 +27,10 @@ declare class ChartCollection {
  * @module
  */
 interface BubbleSeriesData {
-  readonly name: string;
-  readonly xValues: readonly number[];
-  readonly yValues: readonly number[];
-  readonly bubbleSize: readonly number[];
+  name: string;
+  xValues: readonly number[];
+  yValues: readonly number[];
+  bubbleSize: readonly number[];
 }
 declare const TrendlineType: {
   readonly EXP: "exp";
@@ -42,15 +42,15 @@ declare const TrendlineType: {
 };
 type TrendlineType = (typeof TrendlineType)[keyof typeof TrendlineType];
 interface TrendlineOptions {
-  readonly type?: TrendlineType;
-  readonly name?: string;
-  readonly order?: number;
-  readonly period?: number;
-  readonly forward?: number;
-  readonly backward?: number;
-  readonly intercept?: number;
-  readonly dispRSqr?: boolean;
-  readonly dispEq?: boolean;
+  type?: TrendlineType;
+  name?: string;
+  order?: number;
+  period?: number;
+  forward?: number;
+  backward?: number;
+  intercept?: number;
+  dispRSqr?: boolean;
+  dispEq?: boolean;
 }
 declare const ErrorBarDirection: {
   readonly BOTH: "both";
@@ -73,10 +73,10 @@ declare const ErrorValueType: {
 };
 type ErrorValueType = (typeof ErrorValueType)[keyof typeof ErrorValueType];
 interface ErrorBarOptions {
-  readonly direction?: ErrorBarDirection;
-  readonly barType?: ErrorBarType;
-  readonly valueType?: ErrorValueType;
-  readonly value?: number;
+  direction?: ErrorBarDirection;
+  barType?: ErrorBarType;
+  valueType?: ErrorValueType;
+  value?: number;
 }
 declare const DataLabelPosition: {
   readonly BEST_FIT: "bestFit";
@@ -91,31 +91,31 @@ declare const DataLabelPosition: {
 };
 type DataLabelPosition = (typeof DataLabelPosition)[keyof typeof DataLabelPosition];
 interface DataLabelsOptions {
-  readonly position?: DataLabelPosition;
-  readonly showVal?: boolean;
-  readonly showCatName?: boolean;
-  readonly showSerName?: boolean;
-  readonly showPercent?: boolean;
-  readonly showBubbleSize?: boolean;
-  readonly showLeaderLines?: boolean;
+  position?: DataLabelPosition;
+  showVal?: boolean;
+  showCatName?: boolean;
+  showSerName?: boolean;
+  showPercent?: boolean;
+  showBubbleSize?: boolean;
+  showLeaderLines?: boolean;
 }
 interface ChartSeriesData {
-  readonly name: string;
-  readonly values: readonly number[];
-  readonly trendlines?: readonly TrendlineOptions[];
-  readonly errorBars?: ErrorBarOptions;
-  readonly dataLabels?: DataLabelsOptions;
+  name: string;
+  values: readonly number[];
+  trendlines?: readonly TrendlineOptions[];
+  errorBars?: ErrorBarOptions;
+  dataLabels?: DataLabelsOptions;
 }
 type ChartType = "column" | "bar" | "line" | "pie" | "area" | "scatter" | "bubble" | "doughnut" | "radar" | "stock" | "surface";
 type AxisChartType = Exclude<ChartType, "bubble">;
 interface ChartSpaceOptions {
-  readonly title?: string;
-  readonly type: ChartType;
-  readonly categories?: readonly string[];
-  readonly series: readonly ChartSeriesData[] | readonly BubbleSeriesData[];
-  readonly showLegend?: boolean;
-  readonly style?: number;
-  readonly threeD?: boolean;
+  title?: string;
+  type: ChartType;
+  categories?: readonly string[];
+  series: readonly ChartSeriesData[] | readonly BubbleSeriesData[];
+  showLegend?: boolean;
+  style?: number;
+  threeD?: boolean;
 }
 declare const TimeUnit: {
   readonly DAYS: "days";
@@ -124,11 +124,11 @@ declare const TimeUnit: {
 };
 type TimeUnit = (typeof TimeUnit)[keyof typeof TimeUnit];
 interface View3DOptions {
-  readonly rotX?: number;
-  readonly rotY?: number;
-  readonly depthPercent?: number;
-  readonly rAngAx?: boolean;
-  readonly perspective?: number;
+  rotX?: number;
+  rotY?: number;
+  depthPercent?: number;
+  rAngAx?: boolean;
+  perspective?: number;
 }
 //#endregion
 //#region src/chart/chart-descriptors.d.ts

package/dist/{index-eu1aFQCm.d.mts → index-CsQP7Cl4.d.mts}

@@ -55,40 +55,40 @@ declare function stringifyDataModel(points: readonly string[], connections: read
 //#endregion
 //#region src/smartart/data-model/point.d.ts
 interface PointPropertySetOptions {
-  readonly presentationAssociationId?: string;
-  readonly presentationName?: string;
-  readonly presentationStyleLabel?: string;
-  readonly presentationStyleIndex?: number;
-  readonly presentationStyleCount?: number;
-  readonly placeholderText?: string;
-  readonly placeholder?: boolean;
-  readonly customAngle?: number;
-  readonly customFlipVertical?: boolean;
-  readonly customFlipHorizontal?: boolean;
-  readonly customSizeX?: number;
-  readonly customSizeY?: number;
-  readonly customScaleX?: number;
-  readonly customScaleY?: number;
-  readonly customText?: boolean;
-  readonly customLinearFactorX?: number;
-  readonly customLinearFactorY?: number;
-  readonly customLinearFactorNeighborX?: number;
-  readonly customLinearFactorNeighborY?: number;
-  readonly customRadialScaleRadius?: number;
-  readonly customRadialScaleIncrement?: number;
-  readonly coherent3DOffset?: boolean;
-  readonly hideGeometry?: boolean;
-  readonly hideLastTransition?: boolean;
-  readonly lockTextEntry?: boolean;
-  readonly moveWith?: string;
-  readonly useDefault?: boolean;
-  readonly zOrderOffset?: number;
-  readonly layoutTypeId?: string;
-  readonly layoutCategoryId?: string;
-  readonly quickStyleTypeId?: string;
-  readonly quickStyleCategoryId?: string;
-  readonly colorStyleTypeId?: string;
-  readonly colorStyleCategoryId?: string;
+  presentationAssociationId?: string;
+  presentationName?: string;
+  presentationStyleLabel?: string;
+  presentationStyleIndex?: number;
+  presentationStyleCount?: number;
+  placeholderText?: string;
+  placeholder?: boolean;
+  customAngle?: number;
+  customFlipVertical?: boolean;
+  customFlipHorizontal?: boolean;
+  customSizeX?: number;
+  customSizeY?: number;
+  customScaleX?: number;
+  customScaleY?: number;
+  customText?: boolean;
+  customLinearFactorX?: number;
+  customLinearFactorY?: number;
+  customLinearFactorNeighborX?: number;
+  customLinearFactorNeighborY?: number;
+  customRadialScaleRadius?: number;
+  customRadialScaleIncrement?: number;
+  coherent3DOffset?: boolean;
+  hideGeometry?: boolean;
+  hideLastTransition?: boolean;
+  lockTextEntry?: boolean;
+  moveWith?: string;
+  useDefault?: boolean;
+  zOrderOffset?: number;
+  layoutTypeId?: string;
+  layoutCategoryId?: string;
+  quickStyleTypeId?: string;
+  quickStyleCategoryId?: string;
+  colorStyleTypeId?: string;
+  colorStyleCategoryId?: string;
 }
 /**
  * dgm:pt — SmartArt data model point (node) XML stringifier.
@@ -124,8 +124,8 @@ declare class SmartArtCollection {
 //#endregion
 //#region src/smartart/tree-to-model.d.ts
 interface TreeNode {
-  readonly text: string;
-  readonly children?: readonly TreeNode[];
+  text: string;
+  children?: readonly TreeNode[];
 }
 /**
  * Creates SmartArt data model XML from tree nodes with layout/style/color settings.

package/dist/index-DEeO4sOq.d.mts

@@ -0,0 +1,239 @@
+import { Element } from "@office-open/xml";
+import { Buffer } from "\u0000polyfill-node.buffer";
+
+//#region src/util/data-type.d.ts
+/** Supported binary input shapes. */
+type DataType = ArrayBufferLike | Blob | DataView | number[] | ReadableStream | string | Uint8Array;
+/** Test whether a string is a base64 data URL (`data:[mime];base64,...`). */
+declare function isBase64DataURL(input: string): boolean;
+/** Normalize any supported binary input to a `Uint8Array`. */
+declare function toUint8Array(data: DataType): Uint8Array;
+//#endregion
+//#region src/opc/core.d.ts
+type IXmlableObject = Readonly<Record<string, unknown>>;
+/**
+ * Core document properties (docProps/core.xml).
+ *
+ * Shared across docx/pptx/xlsx: each format's top-level Options extends this,
+ * parse emits the same shape, and patch overrides it — read/write symmetry
+ * (CONTRIBUTING §Property Naming). Field names follow the OPC core-properties
+ * XSD element local names (`creator` = dc:creator, … — never `author`).
+ */
+interface CorePropertiesOptions {
+  title?: string;
+  subject?: string;
+  creator?: string;
+  keywords?: string;
+  description?: string;
+  lastModifiedBy?: string;
+  revision?: number;
+  lastPrinted?: string;
+  /** Creation timestamp (W3CDTF), round-tripped from dcterms:created. */
+  created?: string;
+  /** Last modified timestamp (W3CDTF), round-tripped from dcterms:modified. */
+  modified?: string;
+}
+/**
+ * Parse core properties from an already-parsed XML element.
+ * Shared by docx/pptx/xlsx to extract Dublin Core metadata into the unified
+ * {@link CorePropertiesOptions} shape.
+ */
+declare function parseCorePropsElement(el: Element | undefined): CorePropertiesOptions;
+/**
+ * Build a cp:coreProperties XML object from metadata.
+ *
+ * Shared by docx and pptx to avoid duplicating namespace declarations
+ * and Dublin Core property construction.
+ */
+declare function buildCorePropertiesXml(opts: {
+  title?: string;
+  subject?: string;
+  creator?: string;
+  keywords?: string;
+  description?: string;
+  lastModifiedBy?: string;
+  revision?: number;
+}): IXmlableObject;
+/**
+ * Build a cp:coreProperties XML string directly (fast path).
+ *
+ * Shared by pptx and xlsx to bypass the toXml() → xml() pipeline.
+ * created/modified default to now when not supplied; all other fields emit
+ * only when present.
+ */
+declare function buildCorePropertiesXmlString(opts: CorePropertiesOptions): string;
+//#endregion
+//#region src/opc/output.d.ts
+/**
+ * Output type definitions for OOXML document export.
+ *
+ * @module
+ */
+interface OutputByType {
+  base64: string;
+  string: string;
+  text: string;
+  binarystring: string;
+  array: readonly number[];
+  uint8array: Uint8Array;
+  arraybuffer: ArrayBuffer;
+  blob: Blob;
+  nodebuffer: Buffer;
+}
+type OutputType = keyof OutputByType;
+declare const OoxmlMimeType: {
+  readonly DOCX: "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+  readonly PPTX: "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+  readonly XLSX: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+};
+declare const convertOutput: <T extends OutputType>(data: Uint8Array, type: T, mimeType?: string) => OutputByType[T];
+//#endregion
+//#region src/patch/xml-namespace.d.ts
+/**
+ * Namespace configuration for XML patch operations.
+ *
+ * Parameterises element names so the same patch algorithm works for both
+ * DOCX (`w:*`) and PPTX (`a:*`) documents.
+ */
+interface XmlNamespaceConfig {
+  paragraph: string;
+  run: string;
+  text: string;
+  runProperties: string;
+}
+declare const DOCX_NS: XmlNamespaceConfig;
+declare const PPTX_NS: XmlNamespaceConfig;
+//#endregion
+//#region src/patch/xml-replacer.d.ts
+interface ReplacerConfig {
+  ns: XmlNamespaceConfig;
+  formatChild: (child: unknown, context: unknown) => Element[];
+  preserveSpace?: boolean;
+}
+interface ReplacerResult {
+  element: Element;
+  didFindOccurrence: boolean;
+}
+declare function createReplacer(config: ReplacerConfig): ({
+  json,
+  patch,
+  patchText,
+  context,
+  keepOriginalStyles
+}: {
+  json: Element;
+  patch: {
+    type: string;
+    children: readonly unknown[];
+  };
+  patchText: string;
+  context: unknown;
+  keepOriginalStyles?: boolean;
+}) => ReplacerResult;
+//#endregion
+//#region src/patch/run-renderer.d.ts
+interface ElementWrapper {
+  element: Element;
+  index: number;
+  parent: ElementWrapper | undefined;
+}
+interface RenderedParagraphNode {
+  text: string;
+  runs: readonly RenderedRunNode[];
+  index: number;
+  pathToParagraph: readonly number[];
+}
+interface StartAndEnd {
+  start: number;
+  end: number;
+}
+type IParts = {
+  text: string;
+  index: number;
+} & StartAndEnd;
+type RenderedRunNode = {
+  text: string;
+  parts: readonly IParts[];
+  index: number;
+} & StartAndEnd;
+declare function createRunRenderer(ns: XmlNamespaceConfig): (node: ElementWrapper) => RenderedParagraphNode;
+//#endregion
+//#region src/patch/xml-traverser.d.ts
+declare function createTraverser(ns: XmlNamespaceConfig): {
+  traverse: (node: Element) => readonly RenderedParagraphNode[];
+  findLocationOfText: (node: Element, text: string) => readonly RenderedParagraphNode[];
+};
+//#endregion
+//#region src/patch/paragraph-token-replacer.d.ts
+declare function createTokenReplacer(createTextElementContents: (text: string) => Element[], options?: {
+  readonly preserveSpace?: boolean;
+}): ({
+  paragraphElement,
+  renderedParagraph,
+  originalText,
+  replacementText
+}: {
+  paragraphElement: Element;
+  renderedParagraph: RenderedParagraphNode;
+  originalText: string;
+  replacementText: string;
+}) => Element;
+//#endregion
+//#region src/patch/paragraph-split-inject.d.ts
+declare class TokenNotFoundError extends Error {
+  constructor(token: string);
+}
+declare function createSplitInject(ns: XmlNamespaceConfig, createTextElementContents: (text: string) => Element[], options?: {
+  readonly preserveSpace?: boolean;
+}): {
+  findRunElementIndexWithToken: (paragraphElement: Element, token: string) => number;
+  splitRunElement: (runElement: Element, token: string) => {
+    readonly left: Element;
+    readonly right: Element;
+  };
+};
+//#endregion
+//#region src/patch/xml-patch-utils.d.ts
+declare const toJson: (xmlData: string) => Element;
+/**
+ * Creates the inner content of a text element (`w:t` / `a:t`).
+ *
+ * Returns `[{ type: "text", text }]` for non-empty text, `[]` for empty.
+ * The `xml:space` attribute is handled separately by `patchSpaceAttribute`.
+ */
+declare const createTextElementContents: (text: string) => Element[];
+declare const patchSpaceAttribute: (element: Element) => Element;
+declare const getFirstLevelElements: (relationships: Element, id: string) => Element[];
+//#endregion
+//#region src/patch/content-types-manager.d.ts
+declare const appendContentType: (element: Element, contentType: string, extension: string) => void;
+//#endregion
+//#region src/patch/relationship-manager.d.ts
+declare const getNextRelationshipIndex: (relationships: Element) => number;
+declare const appendRelationship: (relationships: Element, id: number | string, type: string, target: string, targetMode?: string) => readonly Element[];
+//#endregion
+//#region src/patch/core-properties-override.d.ts
+declare function applyCorePropertiesOverride(corePropsDoc: Element, overrides: Partial<CorePropertiesOptions>): string;
+//#endregion
+//#region src/patch/types.d.ts
+/** Placeholder delimiter pair surrounding a patch key (e.g. `{{` / `}}`). */
+interface PlaceholderDelimiters {
+  start: string;
+  end: string;
+}
+/**
+ * Shared base options for patch operations.
+ *
+ * Format-specific patch functions extend this with their `patches` field
+ * (and any format-specific options like `keepOriginalStyles`).
+ */
+interface BasePatchOptions<T extends OutputType = OutputType> {
+  /** Source document bytes (Buffer / Uint8Array / ArrayBuffer / base64 data URL / …). */
+  data: DataType;
+  /** Output container type — controls the return type via OutputByType. */
+  outputType: T;
+  /** Custom placeholder delimiters (default `{{` / `}}`). */
+  placeholderDelimiters?: PlaceholderDelimiters;
+}
+//#endregion
+export { DataType as A, OutputByType as C, buildCorePropertiesXml as D, CorePropertiesOptions as E, toUint8Array as M, buildCorePropertiesXmlString as O, OoxmlMimeType as S, convertOutput as T, ReplacerConfig as _, getNextRelationshipIndex as a, PPTX_NS as b, getFirstLevelElements as c, TokenNotFoundError as d, createSplitInject as f, createRunRenderer as g, RenderedParagraphNode as h, appendRelationship as i, isBase64DataURL as j, parseCorePropsElement as k, patchSpaceAttribute as l, createTraverser as m, PlaceholderDelimiters as n, appendContentType as o, createTokenReplacer as p, applyCorePropertiesOverride as r, createTextElementContents as s, BasePatchOptions as t, toJson as u, createReplacer as v, OutputType as w, XmlNamespaceConfig as x, DOCX_NS as y };

package/dist/index-L82O3q6V.d.mts

@@ -0,0 +1,170 @@
+import { Element } from "@office-open/xml";
+
+//#region src/descriptor/context.d.ts
+/** Context passed during stringify (write path). */
+interface WriteContext {
+  /** Register a relationship and return its rId. */
+  addRelationship(type: string, target: string, mode?: string): string;
+  /** Add a media file and return its reference. */
+  addMedia(data: Uint8Array, type: string): string;
+}
+/** Context passed during parse (parse path). */
+interface ReadContext {
+  /** Resolve a relationship rId to its target path. */
+  resolveRelationship(rId: string): string | undefined;
+  /** Get a parsed XML part by path. */
+  getPart(path: string): Element | undefined;
+  /** Get raw binary data (images, media, etc.) by path. */
+  getRaw(path: string): Uint8Array | undefined;
+}
+//#endregion
+//#region src/descriptor/types.d.ts
+/** Custom descriptor — hand-written stringify/parse for an OOXML part. */
+interface CustomDescriptor<T, Ctx = WriteContext> {
+  kind: "custom";
+  stringify(value: T, ctx: Ctx): string | undefined;
+  parse(el: Element, ctx: ReadContext): T;
+}
+/** Alias for "any descriptor" — retained for call-site readability. */
+type Descriptor<T> = CustomDescriptor<T>;
+//#endregion
+//#region src/descriptor/runtime.d.ts
+/**
+ * Serialize an Options object to an XML string using its descriptor.
+ * Returns `undefined` when an optional element should be omitted.
+ */
+declare function stringify$1<T>(desc: CustomDescriptor<T>, value: T, ctx: WriteContext): string | undefined;
+/** Parse an XML Element into an Options object using its descriptor. */
+declare function parse$1<T>(desc: CustomDescriptor<T>, el: Element, ctx: ReadContext): T;
+//#endregion
+//#region src/descriptor/helpers.d.ts
+/**
+ * OOXML-specific encode/decode helpers for descriptors.
+ *
+ * XML traversal helpers (findChild, etc.) are in @office-open/xml utils.
+ * This file only contains OOXML value encoding/decoding.
+ *
+ * @module
+ */
+/** Encode boolean for CT_OnOff: true → omit val, false → "0". */
+declare const boolEncode: (v: boolean | undefined) => string | undefined;
+/** Decode CT_OnOff: absent or "true"/"1" → true, "0"/"false" → false. */
+declare const boolDecode: (raw: string) => boolean;
+/** Create an enum encoder from a JS↔XML mapping. */
+declare const enumEncode: (map: Record<string, string>) => (v: string | undefined) => string | undefined;
+/** Create an enum decoder from a JS↔XML mapping (inverted). */
+declare const enumDecode: (map: Record<string, string>) => (raw: string) => string;
+//#endregion
+//#region src/descriptor/registry.d.ts
+declare class DescriptorRegistry {
+  private static readonly _map;
+  /** Register a descriptor with its XML tag. */
+  static register(tag: string, desc: Descriptor<any>): void;
+  /** Look up a descriptor by XML tag. */
+  static get(tag: string): Descriptor<any> | undefined;
+  /** Get all registered tags. */
+  static tags(): ReadonlySet<string>;
+  /** Check if a tag is registered. */
+  static has(tag: string): boolean;
+  /** Get the number of registered descriptors. */
+  static get size(): number;
+}
+//#endregion
+//#region src/descriptor/field-spec.d.ts
+/**
+ * Declarative field-consistency spec for descriptors.
+ *
+ * The `CustomDescriptor<T>` closure carries no field metadata, so the three
+ * places that must agree — the Options interface, the stringify body, and the
+ * parse body — drift silently (reflection dropping 9/14 props, styles
+ * round-trip loss, core-properties 8-interface/10-write/8-parse inflation).
+ *
+ * Each entry declares the three field sets in a single semantic dimension
+ * (Options field names, not XML tags), so {@link diffTagSets} can surface the
+ * asymmetries directly:
+ *   - F1 write-loss  — declared on the interface but never written
+ *   - F2 write-only  — written but absent from the interface (inflation)
+ *   - F3 parse-loss  — written but never restored on parse (round-trip loss)
+ *   - F5 parse-only  — restored but never written
+ *
+ * @module
+ */
+interface DescriptorFieldSpec {
+  /** Stable identifier, matched to the descriptor under test. */
+  id: string;
+  /** Options interface name (documentation / assertion messages). */
+  optionsInterface: string;
+  /** Fields declared on the Options interface — the contract. */
+  interfaceFields: readonly string[];
+  /** Fields the stringify path actually emits; may carry inflation not on the interface. */
+  writeFields: readonly string[];
+  /** Fields the parse path actually restores. */
+  parseFields: readonly string[];
+  /** Expected child order when the XSD mandates sequence; omitted when order-independent. */
+  order?: readonly string[];
+  /** Sample exercising the interface fields, for F4 round-trip deep-equality. */
+  sampleOptions: unknown;
+  /**
+   * Interface fields excluded from the contract comparison — input-side sugar
+   * (thematicBreak→border, rightTabStop→tabStops) and control flags
+   * (includeIfEmpty) that map field→XML but XML→a different field, breaking the
+   * 1:1 round-trip assumption. The interface-drift test asserts
+   * `interfaceFields === (live interface fields − excludeFields)`.
+   */
+  excludeFields?: readonly string[];
+  notes?: string;
+}
+/**
+ * Curated high-value targets — each maps to a known historical drift.
+ * `settings` is intentionally absent: its round-trip is rawXml-based (byte
+ * passthrough), so field-level diff would mislabel every field as F2.
+ */
+declare const FIELD_SPECS: readonly DescriptorFieldSpec[];
+declare function findFieldSpec(id: string): DescriptorFieldSpec | undefined;
+//#endregion
+//#region src/descriptor/field-consistency.d.ts
+interface FieldConsistencyReport {
+  /** F1 — declared on the interface but never written (write-loss). */
+  f1WriteLoss: readonly string[];
+  /** F2 — written but absent from the interface (write-only inflation). */
+  f2WriteOnly: readonly string[];
+  /** F3 — written but never restored on parse (round-trip loss). */
+  f3ParseLoss: readonly string[];
+  /** F5 — restored on parse but never written (parse-only). */
+  f5ParseOnly: readonly string[];
+}
+/** Diff the interface / write / parse field sets declared on a spec. */
+declare function diffTagSets(spec: DescriptorFieldSpec): FieldConsistencyReport;
+interface RoundTripResult {
+  /** Present in the sample, absent after round-trip. */
+  lost: readonly string[];
+  /** Absent from the sample, present after round-trip. */
+  gained: readonly string[];
+  /** Present on both sides with differing values. */
+  mutated: readonly string[];
+}
+/**
+ * Run a stringify→parse cycle over a sample and diff the result field set.
+ * Returns the F4 round-trip drift. The caller supplies the descriptor's own
+ * stringify/parse (a `CustomDescriptor` pair or a function pair).
+ */
+declare function roundTripFields<T extends object, WC = unknown, RC = unknown>(stringifyFn: (opts: T, ctx: WC) => string | undefined, parseFn: (el: Element, ctx: RC) => T, sample: T, writeCtx: WC, readCtx: RC): RoundTripResult;
+interface OrderViolation {
+  /** Position of the offending child within its parent. */
+  index: number;
+  /** Local name of the child element (namespace prefix stripped). */
+  tag: string;
+  /** Why the child violates the expected sequence. */
+  reason: "unexpected" | "out-of-order";
+}
+/**
+ * Verify the child element order of a stringified container against an XSD
+ * sequence — the F6 check. Namespace prefixes are normalized, so `expected`
+ * entries may be qualified (`w:pStyle`) or local (`pStyle`); both match a
+ * `<w:pStyle>` child. Elements absent from `expected` are flagged "unexpected";
+ * a child whose expected position precedes the previous child's is
+ * "out-of-order".
+ */
+declare function checkOrder(xml: string, expected: readonly string[]): readonly OrderViolation[];
+//#endregion
+export { CustomDescriptor as _, diffTagSets as a, WriteContext as b, FIELD_SPECS as c, boolDecode as d, boolEncode as f, stringify$1 as g, parse$1 as h, checkOrder as i, findFieldSpec as l, enumEncode as m, OrderViolation as n, roundTripFields as o, enumDecode as p, RoundTripResult as r, DescriptorFieldSpec as s, FieldConsistencyReport as t, DescriptorRegistry as u, Descriptor as v, ReadContext as y };