ooxml-core 1.9.0 → 1.11.0

package/dist/pptx/chunks/smart-art-ENMMEbmW.d.ts

@@ -0,0 +1,1512 @@
+import { i as TextStyle, k as XmlObject, r as TextSegment, v as Pptx3DScene, x as Text3DStyle, y as Pptx3DShape } from "./text-D49FKllA.js";
+//#region pptx/core/types/geometry.d.ts
+/**
+ * Geometry types: adjustment handles, custom geometry points, segments,
+ * paths, and custom path properties.
+ *
+ * @module pptx-types/geometry
+ */
+/**
+ * Defines an adjustment handle position for a shape geometry.
+ *
+ * Adjustment handles allow users to interactively reshape preset shapes
+ * (e.g. rounding a rectangle corner or adjusting arrow head width).
+ *
+ * @example
+ * ```ts
+ * const handle: GeometryAdjustmentHandle = {
+ *   guideName: "adj",
+ *   xFraction: 0.25,
+ *   minValue: 0,
+ *   maxValue: 50000,
+ * };
+ * // => satisfies GeometryAdjustmentHandle
+ * ```
+ */
+interface GeometryAdjustmentHandle {
+  /** Name of the adjustment guide this handle controls (e.g. "adj", "adj1"). */
+  guideName: string;
+  /** X position as a fraction of shape width (0..1), or undefined if the handle only moves vertically. */
+  xFraction?: number;
+  /** Y position as a fraction of shape height (0..1), or undefined if the handle only moves horizontally. */
+  yFraction?: number;
+  /** Minimum allowed value for the adjustment guide. */
+  minValue?: number;
+  /** Maximum allowed value for the adjustment guide. */
+  maxValue?: number;
+}
+/**
+ * A single point in a custom geometry path.
+ *
+ * @example
+ * ```ts
+ * const pt: CustomGeometryPoint = { x: 100, y: 200 };
+ * // => satisfies CustomGeometryPoint
+ * ```
+ */
+interface CustomGeometryPoint {
+  x: number;
+  y: number;
+}
+/**
+ * A segment within a custom geometry path.
+ *
+ * Discriminated union over `type` — can be a moveTo, lineTo,
+ * cubic Bézier, quadratic Bézier, or close command.
+ *
+ * @example
+ * ```ts
+ * const segments: CustomGeometrySegment[] = [
+ *   { type: "moveTo", pt: { x: 0, y: 0 } },
+ *   { type: "lineTo", pt: { x: 100, y: 0 } },
+ *   { type: "lineTo", pt: { x: 100, y: 100 } },
+ *   { type: "close" },
+ * ];
+ * // => satisfies CustomGeometrySegment[]
+ * ```
+ */
+type CustomGeometrySegment = {
+  type: 'moveTo';
+  pt: CustomGeometryPoint;
+} | {
+  type: 'lineTo';
+  pt: CustomGeometryPoint;
+} | {
+  type: 'cubicBezTo';
+  pts: [CustomGeometryPoint, CustomGeometryPoint, CustomGeometryPoint];
+} | {
+  type: 'quadBezTo';
+  pts: [CustomGeometryPoint, CustomGeometryPoint];
+} | {
+  type: 'arcTo';
+  /** Horizontal radius of the ellipse. */
+  wR: number;
+  /** Vertical radius of the ellipse. */
+  hR: number;
+  /** Start angle in 60000ths of a degree. */
+  stAng: number;
+  /** Sweep angle in 60000ths of a degree. */
+  swAng: number;
+} | {
+  type: 'close';
+};
+/**
+ * A single sub-path in a custom geometry definition (maps to one `a:path`).
+ *
+ * @example
+ * ```ts
+ * const path: CustomGeometryPath = {
+ *   width: 100,
+ *   height: 100,
+ *   segments: [
+ *     { type: "moveTo", pt: { x: 0, y: 0 } },
+ *     { type: "lineTo", pt: { x: 100, y: 100 } },
+ *   ],
+ * };
+ * // => satisfies CustomGeometryPath
+ * ```
+ */
+interface CustomGeometryPath {
+  /** Coordinate-space width for this sub-path. */
+  width: number;
+  /** Coordinate-space height for this sub-path. */
+  height: number;
+  /** Ordered list of drawing segments. */
+  segments: CustomGeometrySegment[];
+  /** Path fill mode (`a:path/@fill`): norm, lighten, lightenLess, darken, darkenLess, none. */
+  fillMode?: 'norm' | 'lighten' | 'lightenLess' | 'darken' | 'darkenLess' | 'none';
+  /** Whether the path is stroked (`a:path/@stroke`). */
+  stroke?: boolean;
+  /** 3D extrusion compatibility (`a:path/@extrusionOk`). */
+  extrusionOk?: boolean;
+}
+/**
+ * Auxiliary raw XML preserved from `a:custGeom` for round-trip serialization.
+ * These are stored opaquely so adjustment guides, handles, connection sites,
+ * and the text rectangle are not lost when a custGeom is edited and saved.
+ */
+interface CustomGeometryRawData {
+  /** Raw `a:avLst` XML content (adjustment value list). */
+  avLstXml?: unknown;
+  /** Raw `a:gdLst` XML content (guide list). */
+  gdLstXml?: unknown;
+  /** Raw `a:ahLst` XML content (adjustment handles). */
+  ahLstXml?: unknown;
+  /** Raw `a:cxnLst` XML content (connection sites). */
+  cxnLstXml?: unknown;
+  /** Raw `a:rect` XML content (text rectangle). */
+  rectXml?: unknown;
+  /**
+   * Raw `a:pathLst` XML content: every `a:path`'s formula-bearing `a:pt`
+   * x/y attributes, `a:arcTo` params, `a:close`, and per-path `@w`/`@h`/
+   * `@fill`/`@stroke`/`@extrusionOk`, preserved verbatim (not the
+   * parse-time-resolved numbers in `customGeometryPaths`). Lets a live
+   * `shapeAdjustments` drag re-evaluate the outline against the CURRENT
+   * guide values instead of the ones baked in at parse time; see
+   * `geometry/custom-geometry-live-eval.ts`.
+   */
+  pathLstXml?: unknown;
+  /**
+   * Source command order of each `a:path` in {@link pathLstXml} (one list per
+   * path, in document order). The parsed tree groups a path's commands by
+   * type, and the order the parser attaches to it is keyed by object
+   * identity, so it does not survive a copy (undo snapshots, duplicate,
+   * paste, `structuredClone`, reactive proxies). Kept here as plain data so
+   * re-evaluating a copied `pathLstXml` still draws and saves the commands
+   * in their authored order; see `restorePathListCommandOrder`.
+   */
+  pathCommandOrder?: string[][];
+}
+/**
+ * XY-style adjustment handle (`a:ahXY`) on a custom geometry.
+ *
+ * Allows interactive editing of one or two guide values constrained to a
+ * rectangular range. Coordinates are formula references (e.g. `"adj1"`,
+ * `"w/2"`, `"0"`) preserved verbatim so they can re-emit unchanged.
+ *
+ * @example
+ * ```ts
+ * const handle: AdjustHandleXY = {
+ *   gdRefX: "adj1",
+ *   minX: "0",
+ *   maxX: "w",
+ *   posX: "adj1",
+ *   posY: "h/2",
+ * };
+ * // => satisfies AdjustHandleXY
+ * ```
+ */
+interface AdjustHandleXY {
+  /** Guide reference for the X axis (`@_gdRefX`). */
+  gdRefX?: string;
+  /** Guide reference for the Y axis (`@_gdRefY`). */
+  gdRefY?: string;
+  /** Minimum X value, as a formula reference (`@_minX`). */
+  minX?: string;
+  /** Maximum X value (`@_maxX`). */
+  maxX?: string;
+  /** Minimum Y value (`@_minY`). */
+  minY?: string;
+  /** Maximum Y value (`@_maxY`). */
+  maxY?: string;
+  /** Handle position X (formula or literal) from `a:pos/@_x`. */
+  posX?: string;
+  /** Handle position Y from `a:pos/@_y`. */
+  posY?: string;
+}
+/**
+ * Polar-style adjustment handle (`a:ahPolar`) on a custom geometry.
+ *
+ * Drives a guide via radial distance and angle rather than XY coordinates.
+ *
+ * @example
+ * ```ts
+ * const handle: AdjustHandlePolar = {
+ *   gdRefR: "adj1",
+ *   gdRefAng: "adj2",
+ *   posX: "wd2",
+ *   posY: "hd2",
+ * };
+ * // => satisfies AdjustHandlePolar
+ * ```
+ */
+interface AdjustHandlePolar {
+  /** Guide reference for the radial distance (`@_gdRefR`). */
+  gdRefR?: string;
+  /** Guide reference for the angle (`@_gdRefAng`). */
+  gdRefAng?: string;
+  /** Minimum radial value (`@_minR`). */
+  minR?: string;
+  /** Maximum radial value (`@_maxR`). */
+  maxR?: string;
+  /** Minimum angle (`@_minAng`). */
+  minAng?: string;
+  /** Maximum angle (`@_maxAng`). */
+  maxAng?: string;
+  /** Handle position X from `a:pos/@_x`. */
+  posX?: string;
+  /** Handle position Y from `a:pos/@_y`. */
+  posY?: string;
+}
+/**
+ * Connection site (`a:cxn`) on a custom geometry.
+ *
+ * Defines a point on a custom shape that connectors may snap to.
+ *
+ * @example
+ * ```ts
+ * const cxn: ConnectionSite = { ang: "0", posX: "0", posY: "hd2" };
+ * // => satisfies ConnectionSite
+ * ```
+ */
+interface ConnectionSite {
+  /** Approach angle (`@_ang`) — formula or literal degree-1/60000 value. */
+  ang?: string;
+  /** Site position X from `a:pos/@_x`. */
+  posX?: string;
+  /** Site position Y from `a:pos/@_y`. */
+  posY?: string;
+}
+/**
+ * Typed text rectangle (`a:rect`) on a custom geometry.
+ *
+ * Each edge is the formula or literal string preserved from the source XML
+ * (`"l"`, `"t"`, `"r"`, `"b"`, or any guide name / formula).
+ */
+interface CustomGeometryTextRect {
+  /** Left edge formula reference (`@_l`). */
+  l?: string;
+  /** Top edge (`@_t`). */
+  t?: string;
+  /** Right edge (`@_r`). */
+  r?: string;
+  /** Bottom edge (`@_b`). */
+  b?: string;
+}
+/**
+ * Custom (non-preset) geometry path — only on shapes and pictures.
+ *
+ * Contains SVG path data and/or structured custom geometry paths
+ * parsed from `a:custGeom/a:pathLst`.
+ *
+ * @example
+ * ```ts
+ * const custom: PptxCustomPathProperties = {
+ *   pathData: "M 0 0 L 100 0 L 100 100 Z",
+ *   pathWidth: 100,
+ *   pathHeight: 100,
+ * };
+ * // => satisfies PptxCustomPathProperties
+ * ```
+ */
+interface PptxCustomPathProperties {
+  /** SVG path data for custom shapes. */
+  pathData?: string;
+  /** Coordinate-space width for the custom path. */
+  pathWidth?: number;
+  /** Coordinate-space height for the custom path. */
+  pathHeight?: number;
+  /** Structured custom geometry paths for editing (maps to a:custGeom/a:pathLst). */
+  customGeometryPaths?: CustomGeometryPath[];
+  /** Raw adjustment/guide/handle/connection/text-rectangle XML preserved for serialization. */
+  customGeometryRawData?: CustomGeometryRawData;
+  /**
+   * Typed XY adjustment handles parsed from `a:custGeom/a:ahLst/a:ahXY`.
+   * SDK-built shapes can populate this and the writer will emit `<a:ahXY>` entries
+   * even when no raw XML was preserved.
+   */
+  customGeometryAdjustHandlesXY?: AdjustHandleXY[];
+  /**
+   * Typed polar adjustment handles parsed from `a:custGeom/a:ahLst/a:ahPolar`.
+   */
+  customGeometryAdjustHandlesPolar?: AdjustHandlePolar[];
+  /**
+   * Typed connection sites parsed from `a:custGeom/a:cxnLst/a:cxn`.
+   */
+  customGeometryConnectionSites?: ConnectionSite[];
+  /**
+   * Typed text rectangle parsed from `a:custGeom/a:rect`. When present this is
+   * preferred over {@link customGeometryRawData}'s `rectXml` on save.
+   */
+  customGeometryTextRect?: CustomGeometryTextRect;
+}
+//#endregion
+//#region diagram/types.d.ts
+/** Resolved SmartArt layout family. */
+type DiagramLayoutType = 'list' | 'process' | 'cycle' | 'hierarchy' | 'relationship' | 'matrix' | 'pyramid' | 'funnel' | 'gear' | 'target' | 'timeline' | 'venn' | 'chevron' | 'bending' | 'unknown';
+/** SmartArt colour scheme presets. */
+type DiagramColorScheme = 'colorful1' | 'colorful2' | 'colorful3' | 'monochromatic1' | 'monochromatic2';
+/** SmartArt visual style intensity. */
+type DiagramStyleIntensity = 'flat' | 'moderate' | 'intense';
+/** A connection (`dgm:cxn`) between two data-model points. */
+interface DiagramConnection {
+  /** Stable CT_Cxn model identifier. */
+  modelId?: string | null;
+  sourceId: string;
+  destId: string;
+  /** `parOf` (the schema default when omitted), `presOf`, `presParOf`, `unknownRelationship`. */
+  type?: string;
+  srcOrd?: number;
+  destOrd?: number;
+  /** Model ID of the parent transition point associated with this edge. */
+  parentTransitionId?: string | null;
+  /** Model ID of the sibling transition point associated with this edge. */
+  siblingTransitionId?: string | null;
+  /** Layout presentation identifier used by presentation connections. */
+  presentationId?: string | null;
+  /** Text typed onto the linked `parTrans`/`sibTrans` transition point, when it carries any. */
+  label?: string;
+}
+/** Manual layout overrides (`dgm:prSet/@cust*`) a user applied to a presentation point. */
+interface DiagramNodeCustomLayout {
+  /** `custAng`: additional rotation in degrees. */
+  angle?: number;
+  scaleX?: number;
+  scaleY?: number;
+  sizeX?: number;
+  sizeY?: number;
+  flipHorizontal?: boolean;
+  flipVertical?: boolean;
+  linearFactorX?: number;
+  linearFactorY?: number;
+  linearFactorNeighborX?: number;
+  linearFactorNeighborY?: number;
+  radialScaleRadius?: number;
+  radialScaleIncrement?: number;
+  hasCustomTransform?: boolean;
+}
+//#endregion
+//#region diagram/model/constraint-rules.d.ts
+type DiagramConstraintRelationship = 'self' | 'ch' | 'des';
+type DiagramConstraintOperator = 'none' | 'equ' | 'gte' | 'lte';
+type DiagramConstraintPointType = 'all' | 'doc' | 'node' | 'norm' | 'nonNorm' | 'asst' | 'nonAsst' | 'parTrans' | 'pres' | 'sibTrans';
+interface DiagramConstraintTarget {
+  for?: DiagramConstraintRelationship | undefined;
+  forName?: string | undefined;
+  pointType?: DiagramConstraintPointType | undefined;
+}
+/** Editable DiagramML CT_Constraint. */
+interface DiagramConstraint<R = unknown> extends DiagramConstraintTarget {
+  type: string;
+  referenceType?: string | undefined;
+  referenceFor?: DiagramConstraintRelationship | undefined;
+  referenceForName?: string | undefined;
+  referencePointType?: DiagramConstraintPointType | undefined;
+  operator?: DiagramConstraintOperator | undefined;
+  value?: number | undefined;
+  factor?: number | undefined;
+  /** Original constraint retained for foreign attributes and extension content. */
+  rawXml?: R | undefined;
+}
+/** Editable DiagramML CT_NumericRule. */
+interface DiagramNumericRule<R = unknown> extends DiagramConstraintTarget {
+  type: string;
+  value?: number | undefined;
+  factor?: number | undefined;
+  max?: number | undefined;
+  /** Original rule retained for foreign attributes and extension content. */
+  rawXml?: R | undefined;
+}
+//#endregion
+//#region diagram/model/layout-primitives.d.ts
+/**
+ * Leaf DiagramML layout-definition types (localized text, categories,
+ * algorithm parameters, iterator/`dgm:forEach`/`dgm:when`/`dgm:choose`
+ * attributes, and `dgm:shape` metadata). `R` is the raw XML node a reader
+ * keeps for round-trip (pptx: its `XmlObject` tree). Moved from
+ * `pptx/core/types/smart-art-layout-primitives.ts`.
+ */
+interface DiagramLocalizedText {
+  value: string;
+  language?: string;
+}
+interface DiagramLayoutCategory {
+  type: string;
+  priority: number;
+}
+interface DiagramAlgorithmParameter {
+  type: string;
+  value?: string | undefined;
+}
+/** Typed DiagramML CT_Algorithm data attached to a layout node. */
+interface DiagramLayoutAlgorithm {
+  type: string;
+  revision?: number;
+  parameters?: DiagramAlgorithmParameter[];
+}
+interface DiagramIteratorAttributes {
+  name?: string | undefined;
+  reference?: string | undefined;
+  axis?: string[] | undefined;
+  pointTypes?: string[] | undefined;
+  hideLastTransition?: boolean[] | undefined;
+  start?: number[] | undefined;
+  count?: number[] | undefined;
+  step?: number[] | undefined;
+}
+interface DiagramForEach<R = unknown> extends DiagramIteratorAttributes {
+  rawXml?: R;
+}
+interface DiagramWhen<R = unknown> extends DiagramIteratorAttributes {
+  function: string;
+  argument?: string | undefined;
+  operator: string;
+  value: string;
+  rawXml?: R;
+}
+interface DiagramChoose<R = unknown> {
+  name?: string;
+  when: DiagramWhen<R>[];
+  otherwise?: {
+    name?: string;
+    rawXml?: R;
+  } | null;
+  rawXml?: R;
+}
+/** A single `dgm:adj/@val` adjustment, keyed by its `@idx` (1-based, like `a:gd`). */
+interface DiagramShapeAdjustment {
+  index: number;
+  value: number;
+}
+/**
+ * Typed DiagramML CT_Shape data (`dgm:shape`) attached to a layout node: the
+ * per-node preset geometry override real (and third-party/custom) layout
+ * definitions use so a layoutNode can be e.g. an ellipse or a chevron instead
+ * of the arranger family's hardcoded default shape.
+ */
+interface DiagramLayoutNodeShape {
+  /** `dgm:shape/@type`: a preset geometry name (`roundRect`, `ellipse`, `chevron`, `conn`, ...). */
+  presetGeometry?: string;
+  /** `dgm:adjLst/dgm:adj` entries (adjustment index -> value, as authored). */
+  adjustments?: DiagramShapeAdjustment[];
+  /** `dgm:shape/@hideGeom`: the shape is present only to size text, never painted. */
+  hideGeometry?: boolean;
+  /**
+   * `dgm:shape/@lkTxEntry` (CT_Shape, boolean, default false): this node is a
+   * decorative shape that should mirror its paired content node's text
+   * rather than always rendering blank. See `smartart-layout-interpreter-
+   * pyramid.ts`'s `arrangePyramid`, the interpreter's one existing
+   * synthesized-decorative-shape call site.
+   */
+  lkTxEntry?: boolean;
+}
+//#endregion
+//#region diagram/model/layout-definition.d.ts
+/** Identity and ordering metadata from DiagramML CT_LayoutNode. */
+interface DiagramLayoutNode<R = unknown> {
+  name?: string | undefined;
+  styleLabel?: string | undefined;
+  childOrder?: 'b' | 't' | undefined;
+  moveWith?: string | undefined;
+  algorithm?: DiagramLayoutAlgorithm | undefined;
+  forEach?: DiagramForEach<R>[] | undefined;
+  choose?: DiagramChoose<R>[] | undefined;
+  constraints?: DiagramConstraint<R>[] | undefined;
+  rules?: DiagramNumericRule<R>[] | undefined;
+  /** `dgm:shape`: this node's own preset geometry override, when present. */
+  shape?: DiagramLayoutNodeShape | undefined;
+  /**
+   * `dgm:presOf` (CT_PresentationOf, same iterator shape as `dgm:forEach`):
+   * which data-model point(s) this node's OWN text/geometry binds to -
+   * `axis: ['self']` the point currently being iterated, `['des']` all of
+   * its descendants, `['ch']` its direct children, and so on. Absent or
+   * empty `axis` (including a bare `<dgm:presOf/>`) means the node carries
+   * no text of its own (a pure positioning/decoration wrapper - `composite`,
+   * `sp` spacer, connector cap). See `smartart-layout-interpreter-item-
+   * roles.ts`, the one consumer: it is what lets the interpreter tell a
+   * text-bearing per-item role (a list layout's `childText`, a card
+   * layout's `roleText`/`bodyText`) apart from a same-generation sibling
+   * that positions or decorates instead.
+   */
+  presentationOf?: DiagramIteratorAttributes | undefined;
+  /**
+   * EVERY `dgm:constr` reachable from this node, including ones declared
+   * inside a `dgm:choose`/`dgm:if`/`dgm:else` that wraps THIS layoutNode's
+   * `constrLst` (a genuinely conditional constraint set, e.g. one branch
+   * per data-point count - `gear`'s composite positions its `gear1`/
+   * `gear2`/`gear3` slots this way, so its plain, direct-child-only
+   * `constraints` above is empty for it). Stops at a nested `dgm:layoutNode`
+   * boundary: that child's own conditional constrLst becomes ITS
+   * `allConstraints`, not folded into the parent's. Read-only /
+   * interpretation-only - `constraints` above (this node's own DIRECT
+   * constrLst) remains the one `applySmartArtLayoutDefinition` round-trips,
+   * so editing an unrelated property can never collapse a genuinely
+   * conditional constrLst into a single branch. `undefined` when this node
+   * declares no constrLst at all, in or out of a choose (the common case);
+   * otherwise a superset of `constraints` (every branch, blindly unioned -
+   * this interpreter does not evaluate `dgm:choose` conditions when
+   * indexing constraints, matching the same "flatten both branches"
+   * convention `nestedLayoutNodes` already uses for `children`). See
+   * `smartart-constraint-solver.ts`'s `buildConstraintIndex`, the only
+   * consumer.
+   */
+  allConstraints?: DiagramConstraint<R>[] | undefined;
+  children?: DiagramLayoutNode<R>[] | undefined;
+  /**
+   * The iterator attributes of the ENCLOSING `dgm:forEach` this node was
+   * found through, when `nestedLayoutNodes` (`smartart-layout-definition
+   * .ts`) reached it by walking one - as opposed to being a direct child of
+   * its parent layoutNode, or reached only through a `dgm:choose` wrapper
+   * (a condition, not an iteration, leaves this `undefined`).
+   *
+   * `forEach` above records a node's OWN direct `dgm:forEach` children
+   * (which wrap ITS descendants); this is the opposite direction - the
+   * forEach that wraps the node ITSELF, one level up. A layoutNode can sit
+   * inside more than one enclosing forEach only via nesting, so this is
+   * always the SINGLE nearest one, not a list.
+   *
+   * This is what tells a genuinely repeated per-child template
+   * (`axis="ch"`, `ptType` absent or `"node"`) apart from a once-only or
+   * transition-only sibling that merely happens to sit inside SOME
+   * `dgm:forEach` (a `ptType="parTrans"`/`"sibTrans"` connector, or
+   * `axis="followSib" cnt="1"`) - both can be direct siblings under the
+   * SAME parent layoutNode (`lProcess1`'s `vertFlow` has one forEach for
+   * its `parTrans` connector and a SEPARATE one, `axis="ch"`, for its
+   * repeated `child` items; `vertFlow.forEach` bundles both, but only
+   * `child.forEachOrigin` says which ONE produced it). See
+   * `smartart-layout-interpreter-item-roles-recursive.ts`, the one
+   * consumer. Read-only / interpretation-only, like `allConstraints`:
+   * never round-tripped by `applySmartArtLayoutDefinition`.
+   */
+  forEachOrigin?: DiagramIteratorAttributes | undefined;
+  /**
+   * The conditions of EVERY enclosing `dgm:if` this node was found through,
+   * outermost first, when `nestedLayoutNodes` (`smartart-layout-
+   * definition.ts`) reached it via one or more `dgm:choose`'s `if` branches
+   * (as opposed to a direct child, a `dgm:else` branch contributing no
+   * condition of its own - see below - or a `dgm:forEach`, which sets
+   * {@link forEachOrigin} instead). ALL must hold (evaluate `!== false`,
+   * per {@link chooseGuard}'s own AND semantics - see `evaluateWhen`) for
+   * this node's branch to be genuinely live. A caller that already has the
+   * data-model node list can use this instead of treating every
+   * choose-flattened branch as unconditionally present
+   * (`nestedLayoutNodes`' pre-existing "flatten every branch" convention,
+   * still the default when this is absent or a caller does not evaluate
+   * it) - e.g. `cycle-matrix--fallback-n2.pptx`'s `child1group`..
+   * `child4group`, each gated on a DIFFERENT top-level point existing and
+   * having its own child (`axis="ch ch" st="N 1" cnt="1 0" func="cnt"
+   * op="gte" val="1"`).
+   *
+   * A CHAIN, not a single condition, because a node can sit inside NESTED
+   * `dgm:choose`s whose OWN conditions are each individually necessary -
+   * `sub-step-process--hier5.pptx`'s `chLin1`..`chLin7` each sit inside
+   * BOTH an outer `dgm:if func="pos" op="equ" val="N"` (which one of the
+   * 7 hand-duplicated per-position templates this is) AND an inner,
+   * nearly-vacuous `dgm:if func="cnt" op="gte" val="1"` (has >= 1 point at
+   * all) - keeping only the NEAREST (inner) one, as an earlier single-
+   * condition design did, loses the ONE piece of information (the outer
+   * `pos` guard) that actually discriminates `chLin1` from `chLin2`.
+   *
+   * A `dgm:else` branch contributes NO condition of its own (ECMA-376
+   * defines it as "none of the sibling ifs matched", which would need the
+   * FULL sibling list's conditions negated and ANDed together, not a
+   * single condition - no gallery fixture measured needs an else branch's
+   * own guard yet, so it is left unconditional, matching the pre-existing
+   * flatten-everything behaviour) but does NOT clear any OUTER ancestor
+   * guard already accumulated before it. Evaluate with `smartart-layout-
+   * interpreter-when.ts`'s `evaluateWhen`, once per entry, ANDed.
+   */
+  chooseGuard?: DiagramWhen<R>[] | undefined;
+  /**
+   * ROUND 42: the forEach iterator active WHEN EACH ENTRY of {@link
+   * chooseGuard} was declared (index-parallel with it, `undefined` per
+   * entry when no forEach was active at that point) - NOT the same as
+   * {@link forEachOrigin}, which is always this NODE's own single nearest
+   * enclosing forEach, however deep. A `dgm:if` declared ABOVE a `dgm:forEach`
+   * that this node's own branch happens to descend through afterwards needs
+   * ITS OWN, SHALLOWER anchor for a `func="cnt"`/`"maxDepth"`-family
+   * `@axis` condition, not this node's deeper one - `funnel--flat3.pptx`'s
+   * `item1`/`item2`/`item3` (`chooseGuard: [Name5's axis="ch" func="cnt"
+   * op="gte" val="1"]`, declared directly under the composite root, BEFORE
+   * each item's own per-item `dgm:forEach axis="ch" st="2"/"3"/"4" cnt="1"`)
+   * is exactly this shape: evaluating Name5's condition anchored to item1's
+   * OWN forEach binding (one specific data point, with no children of its
+   * own in a flat dataset) wrongly resolves its `axis="ch"` child count to
+   * 0 instead of the diagram's real top-level count, dropping the item
+   * entirely - `chooseGuardOrigins[i]` for that entry is `undefined`
+   * (Name5 sits above ANY forEach), so the guard correctly stays
+   * root-relative. See `smartart-layout-interpreter-composite-
+   * candidates.ts`'s `guardAllows`, the one production consumer.
+   * `undefined` whenever {@link chooseGuard} itself is (no enclosing
+   * choose at all).
+   */
+  chooseGuardOrigins?: (DiagramIteratorAttributes | undefined)[] | undefined;
+  /**
+   * The chain of every enclosing `dgm:choose`'s own GROUP identity + this
+   * node's ordinal position within it + THAT branch's own condition,
+   * outermost first - identifies WHICH `dgm:choose` instance and WHERE
+   * within its own `dgm:if`/`dgm:else` list this node's branch sits, unlike
+   * {@link chooseGuard} (a flat AND-chain of every condition with no group/
+   * position identity, and no entry at all for a `dgm:else` branch, which
+   * has no condition of its own - see that field's doc comment). `id` is a
+   * synthetic, process-unique identifier assigned per `dgm:choose` instance
+   * during flattening (`smartart-layout-definition-nesting.ts`'s
+   * `nestedLayoutNodes`, a monotonic counter - NOT round-tripped, NOT the
+   * choose's own `@_name`, which is not guaranteed unique across a whole
+   * layoutDef); `ordinal` is 0-based document order within that ONE choose
+   * (every `dgm:if` in order, then `dgm:else` last, if present); `guard` is
+   * that branch's OWN condition (`undefined` for a `dgm:else` entry, which
+   * has none - deliberately kept PER-ENTRY rather than cross-referenced by
+   * index against {@link chooseGuard}, whose own length can diverge from
+   * this chain's whenever an ancestor `dgm:else` contributed a group
+   * position but no guard).
+   *
+   * Lets a consumer recover ECMA-376's real `dgm:choose` semantics - "the
+   * FIRST branch whose condition holds wins, siblings never coexist" -
+   * from the flattened `.children` array, where that grouping would
+   * otherwise be lost: `balance--hier5.pptx`'s `balance_NN`/`left_NN_M`/
+   * `right_NN_M` family (127 members across ~30 NESTED `dgm:choose`
+   * instances, not one flat 127-branch choose) needs first-match-wins
+   * WITHIN each individual choose to resolve to the single genuinely-live
+   * arrangement, not the "every guard-true node is an independent
+   * candidate" reading `smartart-layout-interpreter-composite-choose.ts`'s
+   * `collectRawCandidates` used before this field existed - see that
+   * module's own consumer of this field for the actual selection rule.
+   * `undefined` (or an empty array) for a node reached without any
+   * enclosing choose (a direct child, or a `dgm:forEach`-only path) -
+   * every PRE-EXISTING caller that does not consult this field is
+   * unaffected by its mere presence.
+   *
+   * ROUND 42: `origin` is the forEach iterator active when THIS branch's
+   * own `dgm:if`/`dgm:else` was declared (the SAME "declaration time, not
+   * whatever descendant ends up carrying it" concept {@link
+   * chooseGuardOrigins} exists for) - the anchor a `func="cnt"`/`"maxDepth"`
+   * -family condition in `guard` needs, NOT a representative member's own
+   * (possibly deeper) `forEachOrigin`. See `smartart-layout-interpreter-
+   * composite-choose-groups.ts`'s `winningOrdinalFor`, the one consumer.
+   */
+  chooseGroups?: {
+    id: string;
+    ordinal: number;
+    guard?: DiagramWhen<R> | undefined;
+    origin?: DiagramIteratorAttributes | undefined;
+  }[] | undefined;
+  /**
+   * Every `dgm:presOf` candidate reachable through a `dgm:choose`/`dgm:if`/
+   * `dgm:else` wrapping THIS node's OWN presOf (as opposed to
+   * {@link chooseGuard}, which gates the layoutNode's own EXISTENCE), each
+   * tagged with the FULL chain of enclosing `dgm:if` conditions that select
+   * it (`guard`, empty for an unconditional or `dgm:else`-reached
+   * candidate), in document order (every `dgm:if` then `dgm:else` last).
+   * `undefined` when this node's presOf is not choose-guarded at all (the
+   * overwhelmingly common case) - {@link presentationOf} already carries
+   * the one-and-only value then. Exists for a genuinely conditional presOf
+   * where TWO OR MORE branches each declare a real, DIFFERENT axis
+   * (`funnel--flat3.pptx`'s `item1`/`item2`/`item3`, one literal axis per
+   * data-point count): `smartart-layout-definition-constraints.ts`'s
+   * `choosePresentationOf` (feeding {@link presentationOf}) can only ever
+   * guess ONE branch statically, at parse time, with no diagram to
+   * evaluate against; this field lets an interpret-time caller with the
+   * actual diagram (`smartart-layout-interpreter-when.ts`'s
+   * `resolvePresentationOf`, the one consumer) pick the branch PowerPoint's
+   * own runtime would, first-match-wins.
+   */
+  presentationOfCandidates?: {
+    guard: DiagramWhen<R>[];
+    presentationOf: DiagramIteratorAttributes;
+  }[] | undefined;
+  /**
+   * SESSION 17: every `dgm:rule` reachable through a `dgm:choose`/`dgm:if`/
+   * `dgm:else` wrapping THIS node's `ruleLst` (a genuinely count-gated rule
+   * set, e.g. `diverging-radial`'s own `w for="ch" forName="node"` ceiling:
+   * 6 `dgm:if cnt<=N` branches, each its own `fact`), tagged with its guard
+   * chain - the SAME shape {@link presentationOfCandidates} uses for
+   * choose-guarded `presOf`, applied to `dgm:rule`. `undefined` when not
+   * choose-guarded (`rules` above then carries the one set, the common
+   * case). See `smartart-layout-interpreter-cycle-hub-ratio.ts`'s
+   * `resolveHubToNodeRatio` (COM-verified live mechanism, not a guess) for
+   * how the guard is evaluated against the real satellite count.
+   */
+  ruleCandidates?: {
+    guard: DiagramWhen<R>[];
+    rule: DiagramNumericRule<R>;
+  }[] | undefined;
+  /**
+   * ROUND 39: every `dgm:constr` reachable through a `dgm:choose`/`dgm:if`/
+   * `dgm:else` wrapping THIS node's `constrLst` (a genuinely count/position
+   * -branched constraint set, e.g. `basic-venn--flat3.pptx`'s composite
+   * `Name9` choose, one `ctrX`/`ctrY`/`w`/`h` per data-point-count branch
+   * for `circ1`/`circ1Tx`/...), each tagged with its guard chain - the SAME
+   * shape {@link presentationOfCandidates}/{@link ruleCandidates} use,
+   * applied to `dgm:constr`. `undefined` when not choose-guarded
+   * (`allConstraints`/`constraints` above then carry the one set, the
+   * common case). See `smartart-constraint-branch-index.ts`'s
+   * `selectConstraints` for how the guard is evaluated against the real
+   * diagram, and that module's own doc comment for why `allConstraints`'s
+   * pre-existing blind union of every branch is not enough on its own.
+   */
+  constraintCandidates?: {
+    guard: DiagramWhen<R>[];
+    constraint: DiagramConstraint<R>;
+  }[] | undefined;
+}
+/** Metadata and root node from DiagramML CT_DiagramDefinition. */
+interface DiagramLayoutDefinition<R = unknown> {
+  uniqueId?: string | undefined;
+  minimumVersion?: string | undefined;
+  defaultStyle?: string | undefined;
+  titles?: DiagramLocalizedText[] | undefined;
+  descriptions?: DiagramLocalizedText[] | undefined;
+  categories?: DiagramLayoutCategory[] | undefined;
+  rootNode: DiagramLayoutNode<R>;
+  /** Original definition retained for constraint evaluation and foreign rules. */
+  rawXml?: R | undefined;
+  /**
+   * The un-parsed layout-definition part text (starting at `<dgm:layoutDef>`,
+   * XML declaration included). `rawXml` above loses the document order of
+   * differently-named siblings (the package-wide `fast-xml-parser`
+   * configuration groups children into one array per tag), which the
+   * per-point DiagramML engine (`core/utils/smartart-engine/`) needs to
+   * execute a `layoutNode` body's `forEach`/`choose`/`constrLst` statements
+   * in their real declared sequence - see that package's `ordered-xml.ts`.
+   * `undefined` when the part could not be read (matches `rawXml`'s own
+   * optionality); the engine falls back to the legacy interpreter then.
+   */
+  rawXmlText?: string | undefined;
+}
+//#endregion
+//#region diagram/model/style-definition.d.ts
+/** Editable metadata shared by DiagramML quick-style and color definitions. */
+interface DiagramDefinitionText {
+  value: string;
+  language?: string;
+}
+interface DiagramDefinitionCategory {
+  type: string;
+  priority: number;
+}
+type DiagramColorApplicationMethod = 'span' | 'cycle' | 'repeat';
+type DiagramHueDirection = 'cw' | 'ccw';
+/** CT_Colors application metadata. Color-choice children remain preserved XML. */
+interface DiagramColorListMetadata {
+  method?: DiagramColorApplicationMethod;
+  hueDirection?: DiagramHueDirection;
+}
+/**
+ * A quick-style label's `a:lnRef`/`a:fillRef`/`a:effectRef`/`a:fontRef`
+ * (`CT_ShapeStyle`, the same complex type an ordinary shape's `p:style`
+ * uses), resolved against the theme's `fmtScheme` at parse time instead of
+ * the coarse subtle/moderate/intense enum ({@link DiagramQuickStyle.effectIntensity}).
+ * Only populated when a theme format scheme was available when the quick
+ * style was parsed. See G13 in the 2026-09 diagram audit.
+ */
+interface DiagramResolvedStyleRef {
+  fillColor?: string;
+  fillMode?: 'solid' | 'gradient' | 'pattern' | 'none' | 'theme';
+  strokeColor?: string;
+  strokeWidth?: number;
+  /** `a:effectRef`'s theme-resolved outer shadow colour, when the style has one. */
+  shadowColor?: string;
+  /** `a:fontRef`'s theme-resolved typeface (`+mn-lt`/`+mj-lt` -> the theme's actual font). */
+  fontTypeface?: string;
+}
+/** CT_StyleLabel metadata from a quick-style definition. */
+interface DiagramQuickStyleLabel<Scene = unknown, Shape = unknown, Text = unknown> {
+  name: string;
+  /** Theme-resolved `dgm:style` refs for this label's role, when available. */
+  resolvedStyle?: DiagramResolvedStyleRef;
+  /**
+   * The label's own `dgm:scene3d` (per-shape camera + light rig). PowerPoint
+   * copies it onto a shape's cached `a:scene3d` unless it is the default
+   * front camera with a `threePt` light (see `applySmartArtQuickStyle3d`).
+   */
+  scene3d?: Scene;
+  /** The label's own `dgm:sp3d` (bevel / extrusion / contour / material); absent when empty. */
+  shape3d?: Shape;
+  /** The label's `dgm:txPr/a:sp3d` label-text extrusion (Bird's Eye Scene). */
+  text3d?: Text;
+}
+/** CT_CTStyleLabel metadata from a color-transform definition. */
+interface DiagramColorTransformLabel {
+  name: string;
+  fill?: DiagramColorListMetadata;
+  line?: DiagramColorListMetadata;
+  effect?: DiagramColorListMetadata;
+  textLine?: DiagramColorListMetadata;
+  textFill?: DiagramColorListMetadata;
+  textEffect?: DiagramColorListMetadata;
+}
+interface DiagramDefinitionMetadata {
+  uniqueId?: string;
+  minimumVersion?: string;
+  titles?: DiagramDefinitionText[];
+  descriptions?: DiagramDefinitionText[];
+  categories?: DiagramDefinitionCategory[];
+}
+/** Typed CT_ColorTransform metadata and the resolved legacy color palette. */
+interface DiagramColorTransform extends DiagramDefinitionMetadata {
+  /** Legacy resolved display name. */
+  name?: string;
+  /** Ordered resolved fill colors for rendering. */
+  fillColors: string[];
+  /** Ordered resolved line colors for rendering. */
+  lineColors: string[];
+  /** Ordered resolved text-fill colors (primary styleLbl `txFillClrLst`). */
+  textFillColors?: string[];
+  /** Ordered resolved text-line colors (primary styleLbl `txLinClrLst`). */
+  textLineColors?: string[];
+  /** Ordered resolved effect colors (primary styleLbl `effectClrLst`). */
+  effectColors?: string[];
+  /** Ordered resolved text-effect colors (primary styleLbl `txEffectClrLst`). */
+  textEffectColors?: string[];
+  /** Fill-list span/cycle + hue-direction interpolation of the primary styleLbl. */
+  fillInterpolation?: DiagramColorListMetadata;
+  /** Line-list span/cycle + hue-direction interpolation of the primary styleLbl. */
+  lineInterpolation?: DiagramColorListMetadata;
+  /** Ordered CT_CTStyleLabel metadata. */
+  labels?: DiagramColorTransformLabel[];
+  /**
+   * Every `styleLbl`'s own resolved fill/line colour list, keyed by name
+   * (e.g. `node1`, `asst0`, `bgShp`, `revTx`). Unlike {@link fillColors} /
+   * {@link lineColors} (which collapse to ONE "primary" node-role list),
+   * this keeps every role so a node can be coloured from its OWN role's
+   * palette (see `DiagramNode.styleRole` and `applySmartArtRoleColors`)
+   * instead of a generic cycled colour.
+   */
+  roleColors?: Record<string, DiagramRoleColorList>;
+}
+/** One colour-transform `styleLbl`'s resolved colour lists. */
+interface DiagramRoleColorList {
+  fill: string[];
+  line: string[];
+  /**
+   * `txFillClrLst`, when the label declares one (`revTx` -> `tx1`). A text
+   * node's colour comes from here; see `smartart-merged-text-label`.
+   */
+  textFill?: string[];
+}
+/** Typed CT_StyleDefinition metadata and legacy rendering hint. */
+interface DiagramQuickStyle<Scene = unknown, Shape = unknown, Text = unknown> extends DiagramDefinitionMetadata {
+  /** Legacy resolved display name. */
+  name?: string;
+  /** Legacy effect-intensity rendering hint. */
+  effectIntensity?: string;
+  /** Ordered CT_StyleLabel metadata. Complex style payload remains preserved XML. */
+  labels?: DiagramQuickStyleLabel<Scene, Shape, Text>[];
+  /**
+   * Whole-diagram 3D scene (camera preset/rotation/zoom/fov, light rig,
+   * backdrop) from the quick style's own `dgm:styleDef/dgm:scene3d`, present
+   * for the "Scene" quick styles (Brick, Flat, Metallic, Sunset, Bird's Eye
+   * Scene). One camera renders the whole diagram; per-shape `a:scene3d` is
+   * absent for those styles (see the cached drawing shape's own `scene3d`). Each
+   * `dgm:styleLbl` also carries its own per-label `dgm:scene3d`/`dgm:sp3d`
+   * ({@link DiagramQuickStyleLabel.scene3d} / `shape3d` / `text3d`),
+   * which PowerPoint bakes onto each cached shape; they are re-applied when a
+   * structural edit regenerates the shapes.
+   */
+  scene3d?: Scene;
+}
+//#endregion
+//#region diagram/model/node.d.ts
+/**
+ * A single run of text inside a SmartArt node, capturing the run text and the
+ * raw `a:rPr` run-properties object verbatim so per-run formatting (bold,
+ * colour, size, etc.) survives a load -> edit -> save round-trip instead of
+ * collapsing to a single unstyled run.
+ *
+ * @example
+ * ```ts
+ * const run: DiagramNodeTextRun = {
+ *   text: "Bold",
+ *   rPr: { "@_b": "1", "@_lang": "en-US" },
+ * };
+ * // => satisfies DiagramNodeTextRun
+ * ```
+ */
+interface DiagramNodeTextRun<S = unknown> {
+  /** Run text content. */
+  text: string;
+  /**
+   * Raw parsed `a:rPr` run-properties object, preserved verbatim for
+   * round-trip. Untyped XML, hence the loose record shape.
+   */
+  rPr?: Record<string, unknown>;
+  /** Resolved standard shape-text style derived from {@link rPr}. */
+  style?: S;
+  /** Raw run XML used to retain unmodelled extension children on save. */
+  rawXml?: Record<string, unknown>;
+  /** Original direct-child order, including unmodelled extension children. */
+  childOrder?: string[];
+}
+/** An ordered item within a SmartArt text paragraph. */
+type DiagramNodeTextParagraphItem<S = unknown> = {
+  kind: 'run';
+  run: DiagramNodeTextRun<S>;
+} | {
+  kind: 'break';
+  rPr?: Record<string, unknown>;
+  style?: S;
+  rawXml?: Record<string, unknown>;
+  childOrder?: string[];
+} | {
+  kind: 'field';
+  id?: string;
+  fieldType?: string;
+  text: string;
+  rPr?: Record<string, unknown>;
+  style?: S;
+  pPr?: Record<string, unknown>;
+  rawXml?: Record<string, unknown>;
+  childOrder?: string[];
+} | {
+  kind: 'tab';
+  rawXml?: Record<string, unknown>;
+  childOrder?: string[];
+} | {
+  kind: 'raw';
+  name: string;
+  value: unknown;
+};
+/** A complete `a:p` paragraph in a SmartArt data-model text body. */
+interface DiagramNodeTextParagraph<S = unknown> {
+  /** Paragraph properties (`a:pPr`) preserved verbatim. */
+  pPr?: Record<string, unknown>;
+  /** Text children in source order. */
+  items: DiagramNodeTextParagraphItem<S>[];
+  /** End-paragraph run properties (`a:endParaRPr`) preserved verbatim. */
+  endParaRPr?: Record<string, unknown>;
+  /** Resolved style for the paragraph terminator. */
+  endParaStyle?: S;
+  /** Raw paragraph XML used to retain unmodelled extension children on save. */
+  rawXml?: Record<string, unknown>;
+}
+/**
+ * Per-node visual override for a SmartArt node.
+ *
+ * Captures the individual fill / line / font colour and the bold / italic
+ * emphasis a user has set on one specific node, independent of the diagram's
+ * colour scheme and quick style. All colours are hex strings (e.g. "#FF0000").
+ * Every field is optional: only the overridden aspects are carried, so an
+ * empty object means "no per-node override".
+ *
+ * The parser reads these from the data point's `spPr` solid fill / line colour
+ * and the first run's `rPr` (b / i / solidFill) when present, and the save path
+ * writes them back so the override survives a load -> edit -> save round-trip.
+ *
+ * @example
+ * ```ts
+ * const style: DiagramNodeStyle = {
+ *   fillColor: "#FF0000",
+ *   fontColor: "#FFFFFF",
+ *   bold: true,
+ * };
+ * // => satisfies DiagramNodeStyle
+ * ```
+ */
+interface DiagramNodeStyle {
+  /** Solid fill colour override (hex, e.g. "#4F81BD"). */
+  fillColor?: string;
+  /** Outline / line colour override (hex). */
+  lineColor?: string;
+  /** Text (font) colour override (hex). */
+  fontColor?: string;
+  /** Bold emphasis override for the node's runs. */
+  bold?: boolean;
+  /** Italic emphasis override for the node's runs. */
+  italic?: boolean;
+}
+/**
+ * A single node in the SmartArt data model.
+ *
+ * @example
+ * ```ts
+ * const node: DiagramNode = {
+ *   id: "1",
+ *   text: "CEO",
+ *   children: [
+ *     { id: "2", text: "VP Marketing", parentId: "1" },
+ *     { id: "3", text: "VP Engineering", parentId: "1" },
+ *   ],
+ * };
+ * // => satisfies DiagramNode
+ * ```
+ */
+interface DiagramNode<S = unknown> {
+  id: string;
+  text: string;
+  /** CT_Pt connection identifier, when the point references a connection. */
+  connectionId?: string | null;
+  parentId?: string | undefined;
+  children?: DiagramNode<S>[];
+  /** Node type from `@_type` attribute (e.g. "doc", "node", "asst", "pres"). */
+  nodeType?: string;
+  /**
+   * The node's own quick-style role (`dgm:prSet/@presStyleLbl` from its
+   * paired `type="pres"` presentation point, resolved via a `presOf`
+   * connection back to this content point). Structural names like `node1`,
+   * `asst2`, `bgShp`, `revTx`; distinct from {@link nodeType}, which is the
+   * data-model `@_type` ("node"/"asst"/...). Used to pick this node's own
+   * colour list from a colour transform's per-role palettes instead of the
+   * generic cycled palette (see `applySmartArtRoleColors`).
+   */
+  styleRole?: string;
+  /**
+   * `dgm:prSet/@coherent3DOff` (`CT_ElemPropSet`) resolved from the node's
+   * paired presentation point: when true, this node opts out of the
+   * diagram's overall coherent-3D scene rotation (a `dgm:scene3d`/`dgm:sp3d`
+   * quick-style variation) applied to every other node.
+   */
+  coherent3DOff?: boolean;
+  /**
+   * The layout variables PowerPoint recorded for each presentation node
+   * this point drives (`dgm:prSet/@presName` -> `dgm:presLayoutVars`
+   * variable -> `@val`), e.g. `{ hierRoot1: { hierBranch: 'l' } }` for an
+   * org-chart manager set to "Left Hanging". Read-only: the presentation
+   * points themselves round-trip verbatim.
+   */
+  presLayoutVarsByName?: Record<string, Record<string, string>>;
+  /**
+   * Per-run text + run-properties for the node's first paragraph, captured at
+   * parse time. When the joined run text still equals {@link text} (the node
+   * was not edited, or was edited only in ways that preserve the run split),
+   * the save path rebuilds the paragraph from these runs so per-run rich text
+   * is not flattened. When {@link text} diverges, the runs are ignored.
+   */
+  runs?: DiagramNodeTextRun<S>[];
+  /**
+   * Complete typed paragraph model. Unlike {@link runs}, this retains every
+   * paragraph and the ordered run, field, break, and tab children within it.
+   */
+  paragraphs?: DiagramNodeTextParagraph<S>[];
+  /**
+   * Optional per-node visual override (fill / line / font colour, bold /
+   * italic). Read at parse time from the point's `spPr` / first-run `rPr`, set
+   * by the editing op, honoured by the render path, and written back on save so
+   * it round-trips.
+   */
+  style?: DiagramNodeStyle;
+  /**
+   * Manual layout override read from the node's `dgm:prSet` `cust*`
+   * attributes (drag/resize/rotate/flip performed in PowerPoint's own diagram
+   * editor). Applied as a final transform after algorithmic layout by
+   * {@link module:smartart-layout-interpreter-custom} so it survives even
+   * when there is no cached `dsp:` drawing to fall back on.
+   */
+  customLayout?: DiagramNodeCustomLayout;
+}
+//#endregion
+//#region diagram/model/data.d.ts
+/**
+ * Named SmartArt layout presets for creation (subset of the built-in layouts).
+ *
+ * @example
+ * ```ts
+ * const layout: DiagramLayoutPreset = "hierarchy";
+ * // => "hierarchy" - one of: "basicBlockList" | "alternatingHexagons" | "hierarchy" | ...
+ * ```
+ */
+type DiagramLayoutPreset = 'basicBlockList' | 'alternatingHexagons' | 'basicChevronProcess' | 'basicCycle' | 'basicPie' | 'basicRadial' | 'basicVenn' | 'continuousBlockProcess' | 'convergingRadial' | 'hierarchy' | 'horizontalBulletList' | 'linearVenn' | 'segmentedProcess' | 'stackedList' | 'tableList' | 'trapezoidList' | 'upwardArrow' | 'basicFunnel' | 'basicTarget' | 'interlockingGears' | 'basicTimeline' | 'basicMatrix' | 'basicPyramid' | 'invertedPyramid' | 'bendingProcess' | 'stepDownProcess' | 'alternatingFlow' | 'descendingProcess' | 'pictureAccentList' | 'verticalBlockList' | 'groupedList' | 'pyramidList' | 'horizontalPictureList' | 'accentProcess' | 'verticalChevronList';
+/**
+ * Presentation layout variables from `dgm:prSet/dgm:presLayoutVars` (data model)
+ * or `dgm:varLst` (layout definition defaults).
+ *
+ * These drive how the DiagramML layout interpreter arranges points: flow
+ * direction, hierarchy branch style, org-chart mode, and child count limits.
+ * The fallback layout engine can consult them for direction/org-chart hints.
+ *
+ * @example
+ * ```ts
+ * const vars: DiagramPresLayoutVars = { direction: "rev", orgChart: true };
+ * // => satisfies DiagramPresLayoutVars
+ * ```
+ */
+interface DiagramPresLayoutVars {
+  /** Flow direction (`dgm:dir`): "norm" (default) or "rev" (reversed/RTL). */
+  direction?: 'norm' | 'rev';
+  /** Hierarchy branch style (`dgm:hierBranch`): std/init/l/r/hang. */
+  hierarchyBranch?: 'std' | 'init' | 'l' | 'r' | 'hang';
+  /** Org-chart mode enabled (`dgm:orgChart`). */
+  orgChart?: boolean;
+  /** Maximum children per node (`dgm:chMax`, -1 = unbounded). */
+  childMax?: number;
+  /** Preferred children per node (`dgm:chPref`, -1 = unbounded). */
+  childPreferred?: number;
+  /** Whether bullets are enabled (`dgm:bulletEnabled`). */
+  bulletEnabled?: boolean;
+  /** Animation-by-level setting (`dgm:animLvl`). */
+  animationLevel?: string;
+  /** Animate-one setting (`dgm:animOne`). */
+  animateOne?: string;
+  /** Allowed resize handles (`dgm:resizeHandles`). */
+  resizeHandles?: string;
+}
+/**
+ * The format-neutral part of a parsed SmartArt graphic: everything the layout
+ * engine and interpreters read.
+ *
+ * @example
+ * ```ts
+ * const data: DiagramData = {
+ *   resolvedLayoutType: "hierarchy",
+ *   layout: "hierarchy",
+ *   colorScheme: "colorful1",
+ *   style: "moderate",
+ *   nodes: [
+ *     { id: "1", text: "CEO", children: [
+ *       { id: "2", text: "VP Marketing", parentId: "1" },
+ *     ]},
+ *   ],
+ * };
+ * // => satisfies DiagramData
+ * ```
+ */
+interface DiagramData {
+  layoutType?: string;
+  resolvedLayoutType?: DiagramLayoutType;
+  /** Named layout preset (used when creating new SmartArt). */
+  layout?: DiagramLayoutPreset;
+  /** Colour scheme for the SmartArt graphic. */
+  colorScheme?: DiagramColorScheme;
+  /** Visual style intensity. */
+  style?: DiagramStyleIntensity;
+  nodes: DiagramNode[];
+  /** Connections between data-model nodes. */
+  connections?: DiagramConnection[];
+  /** Colour transform from the diagram colours part. */
+  colorTransform?: DiagramColorTransform;
+  /** Quick style from the diagram quick-style part. */
+  quickStyle?: DiagramQuickStyle;
+  /** Editable metadata from the related DiagramML layout definition. */
+  layoutDefinition?: DiagramLayoutDefinition;
+  /**
+   * Presentation layout variables (direction, hierarchy branch, org-chart,
+   * child limits, bullets) from `dgm:presLayoutVars` / layout `dgm:varLst`.
+   * Consulted by the fallback layout engine for direction/org-chart hints.
+   */
+  presLayoutVars?: DiagramPresLayoutVars;
+  /**
+   * The document theme's minor-Latin font (`a:fontScheme/a:minorFont/a:latin/
+   * @typeface`): what SmartArt text actually renders in when no per-run
+   * `a:latin` override is present (the common case; the font-fit is the one
+   * consumer). Undefined when the theme carries no font scheme at all.
+   */
+  themeMinorFont?: string;
+}
+//#endregion
+//#region pptx/core/types/smart-art-chrome.d.ts
+/**
+ * Background / outline extracted from `dgm:bg` and `dgm:whole`.
+ *
+ * @example
+ * ```ts
+ * const chrome: PptxSmartArtChrome = {
+ *   backgroundColor: "#F0F0F0",
+ *   outlineColor: "#333333",
+ *   outlineWidth: 1,
+ * };
+ * // => satisfies PptxSmartArtChrome
+ * ```
+ */
+interface PptxSmartArtChrome {
+  /**
+   * Background fill colour (hex). When the real `dgm:bg` fill is a gradient
+   * or pattern (see {@link PptxSmartArtChrome.backgroundFillXml}), this is an
+   * APPROXIMATION (the gradient's first stop, or the pattern's foreground
+   * colour) for a consumer that only wants one display colour, not the full fill.
+   */
+  backgroundColor?: string;
+  /**
+   * Raw `dgm:bg` fill XML, present only when the background is a gradient or
+   * pattern fill (a solid fill is fully captured by {@link PptxSmartArtChrome.backgroundColor}
+   * alone). Round-trip only: `smartart-save-chrome.ts` re-emits this verbatim
+   * instead of flattening the fill to a solid colour on save.
+   */
+  backgroundFillXml?: PptxSmartArtRawBackgroundFill;
+  /** Outline stroke colour (hex). */
+  outlineColor?: string;
+  /** Outline stroke width in points. */
+  outlineWidth?: number;
+}
+/**
+ * A `dgm:bg` fill this viewer doesn't fully model as first-class chrome
+ * (gradient or pattern), preserved verbatim for round-trip. See
+ * {@link PptxSmartArtChrome.backgroundFillXml}.
+ */
+interface PptxSmartArtRawBackgroundFill {
+  /** Local element name of the fill under `dgm:bg` (`gradFill` or `pattFill`). */
+  localName: 'gradFill' | 'pattFill';
+  /** The fill element's own attributes/children, as parsed. */
+  xml: XmlObject;
+}
+//#endregion
+//#region pptx/core/types/smart-art-model.d.ts
+type PptxSmartArtConstraintRelationship = DiagramConstraintRelationship;
+type PptxSmartArtConstraintOperator = DiagramConstraintOperator;
+type PptxSmartArtConstraintPointType = DiagramConstraintPointType;
+type PptxSmartArtConstraintTarget = DiagramConstraintTarget;
+type PptxSmartArtConstraint = DiagramConstraint<XmlObject>;
+type PptxSmartArtNumericRule = DiagramNumericRule<XmlObject>;
+type PptxSmartArtLocalizedText = DiagramLocalizedText;
+type PptxSmartArtLayoutCategory = DiagramLayoutCategory;
+type PptxSmartArtAlgorithmParameter = DiagramAlgorithmParameter;
+type PptxSmartArtLayoutAlgorithm = DiagramLayoutAlgorithm;
+type PptxSmartArtIteratorAttributes = DiagramIteratorAttributes;
+type PptxSmartArtForEach = DiagramForEach<XmlObject>;
+type PptxSmartArtWhen = DiagramWhen<XmlObject>;
+type PptxSmartArtChoose = DiagramChoose<XmlObject>;
+type PptxSmartArtShapeAdjustment = DiagramShapeAdjustment;
+type PptxSmartArtLayoutNodeShape = DiagramLayoutNodeShape;
+type PptxSmartArtLayoutNode = DiagramLayoutNode<XmlObject>;
+type PptxSmartArtLayoutDefinition = DiagramLayoutDefinition<XmlObject>;
+type PptxSmartArtDefinitionText = DiagramDefinitionText;
+type PptxSmartArtDefinitionCategory = DiagramDefinitionCategory;
+type PptxSmartArtColorApplicationMethod = DiagramColorApplicationMethod;
+type PptxSmartArtHueDirection = DiagramHueDirection;
+type PptxSmartArtColorListMetadata = DiagramColorListMetadata;
+type PptxSmartArtResolvedStyleRef = DiagramResolvedStyleRef;
+type PptxSmartArtQuickStyleLabel = DiagramQuickStyleLabel<Pptx3DScene, Pptx3DShape, Text3DStyle>;
+type PptxSmartArtColorStyleLabel = DiagramColorTransformLabel;
+type PptxSmartArtDefinitionMetadata = DiagramDefinitionMetadata;
+type PptxSmartArtColorTransform = DiagramColorTransform;
+type SmartArtRoleColorList = DiagramRoleColorList;
+type PptxSmartArtQuickStyle = DiagramQuickStyle<Pptx3DScene, Pptx3DShape, Text3DStyle>;
+type PptxSmartArtTextRun = DiagramNodeTextRun<TextStyle>;
+type PptxSmartArtTextParagraphItem = DiagramNodeTextParagraphItem<TextStyle>;
+type PptxSmartArtTextParagraph = DiagramNodeTextParagraph<TextStyle>;
+type PptxSmartArtNodeStyle = DiagramNodeStyle;
+type PptxSmartArtNode = DiagramNode<TextStyle>;
+/**
+ * Manual layout override for a `type="pres"` presentation point, read from its
+ * `dgm:prSet` `cust*` attributes (see `DiagramNodeCustomLayout`).
+ */
+type SmartArtNodeCustomLayout = DiagramNodeCustomLayout;
+type SmartArtLayout = DiagramLayoutPreset;
+type PptxSmartArtPresLayoutVars = DiagramPresLayoutVars;
+//#endregion
+//#region pptx/core/types/smart-art.d.ts
+/**
+ * Resolved SmartArt layout category.
+ *
+ * @example
+ * ```ts
+ * const cat: SmartArtLayoutType = "hierarchy";
+ * // => "hierarchy" — one of: "list" | "process" | "cycle" | "hierarchy" | "relationship" | …
+ * ```
+ */
+type SmartArtLayoutType = DiagramLayoutType;
+/**
+ * SmartArt colour scheme presets.
+ *
+ * @example
+ * ```ts
+ * const scheme: SmartArtColorScheme = "colorful1";
+ * // => "colorful1" — one of: "colorful1" | "colorful2" | "colorful3" | "monochromatic1" | "monochromatic2"
+ * ```
+ */
+type SmartArtColorScheme = DiagramColorScheme;
+/**
+ * SmartArt visual style intensity.
+ *
+ * @example
+ * ```ts
+ * const style: SmartArtStyle = "moderate";
+ * // => "moderate" — one of: "flat" | "moderate" | "intense"
+ * ```
+ */
+type SmartArtStyle = DiagramStyleIntensity;
+/**
+ * A connection between two SmartArt data-model nodes.
+ *
+ * @example
+ * ```ts
+ * const conn: PptxSmartArtConnection = {
+ *   sourceId: "1",
+ *   destId: "2",
+ *   type: "parOf",
+ * };
+ * // => satisfies PptxSmartArtConnection
+ * ```
+ */
+type PptxSmartArtConnection = DiagramConnection;
+/**
+ * A pre-computed shape from `ppt/diagrams/drawing*.xml`.
+ *
+ * @example
+ * ```ts
+ * const shape: PptxSmartArtDrawingShape = {
+ *   id: "s1",
+ *   shapeType: "roundRect",
+ *   x: 100, y: 50, width: 200, height: 80,
+ *   fillColor: "#4F81BD",
+ *   text: "CEO",
+ * };
+ * // => satisfies PptxSmartArtDrawingShape
+ * ```
+ */
+interface PptxSmartArtDrawingShape extends PptxCustomPathProperties {
+  /** Shape ID within the drawing. */
+  id: string;
+  /** Preset geometry type (e.g. "roundRect", "ellipse"). */
+  shapeType?: string;
+  /** Position and size in EMU-based pixels. */
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  /** Rotation in degrees. */
+  rotation?: number;
+  /** Horizontal/vertical mirrors declared on the cached drawing transform. */
+  flipHorizontal?: boolean;
+  flipVertical?: boolean;
+  /** Skew along the X axis in degrees. */
+  skewX?: number;
+  /** Skew along the Y axis in degrees. */
+  skewY?: number;
+  /** Preset-geometry adjustment values from `a:prstGeom/a:avLst`. */
+  shapeAdjustments?: Record<string, number>;
+  /**
+   * The cached shape declares `a:noFill`. Renderers must leave it unpainted
+   * rather than substituting a palette colour, because these shapes usually sit
+   * on top of a painted shape whose fill has to stay visible.
+   */
+  fillNone?: boolean;
+  /** Solid fill colour (hex). */
+  fillColor?: string;
+  /**
+   * Opacity (0..1) of the solid fill, from the colour's `a:alpha` (Basic Venn
+   * paints its circles at 50% so overlaps blend). Absent when opaque.
+   */
+  fillOpacity?: number;
+  /**
+   * Gradient fill stops when the cached shape uses `a:gradFill`. Positions are
+   * 0..100 (percent). Renderers emit an SVG/CSS gradient instead of a flat box.
+   */
+  fillGradientStops?: Array<{
+    color: string;
+    position: number;
+    opacity?: number;
+  }>;
+  /** Gradient geometry type (`linear` for `a:lin`, `radial` for `a:path`). */
+  fillGradientType?: 'linear' | 'radial';
+  /** Linear gradient angle in degrees (0..360). */
+  fillGradientAngle?: number;
+  /** Pattern fill preset name from `a:pattFill/@prst` (e.g. "pct50", "cross"). */
+  fillPatternPreset?: string;
+  /** Pattern fill foreground colour (hex) from `a:pattFill/a:fgClr`. */
+  fillPatternForegroundColor?: string;
+  /** Pattern fill background colour (hex) from `a:pattFill/a:bgClr`. */
+  fillPatternBackgroundColor?: string;
+  /**
+   * Relationship id of a picture (blip) fill's embedded image, from
+   * `a:blipFill/a:blip/@r:embed`. The image bytes are resolved separately; see
+   * {@link fillImageUrl}.
+   */
+  fillBlipEmbedId?: string;
+  /**
+   * Resolved data-URI/URL for a picture (blip) fill, when the embedded image
+   * part could be resolved. Absent when only {@link fillBlipEmbedId} is known.
+   */
+  fillImageUrl?: string;
+  /** Whether the cached shape carries an outer-shadow effect (`a:effectLst`). */
+  hasShadow?: boolean;
+  /** Resolved outer-shadow colour (hex), when present. */
+  shadowColor?: string;
+  /** Stroke colour (hex). */
+  strokeColor?: string;
+  /** Stroke width in points. */
+  strokeWidth?: number;
+  /** Text content of the shape. */
+  text?: string;
+  /** Standard rich-text segments projected from the associated SmartArt node. */
+  textSegments?: TextSegment[];
+  /** Font size in CSS pixels. */
+  fontSize?: number;
+  /** Font colour (hex). */
+  fontColor?: string;
+  /** Authored font family from the first styled run. */
+  fontFamily?: string;
+  /** Authored font weight (400 or 700). */
+  fontWeight?: number;
+  /** Authored font style. */
+  fontStyle?: 'normal' | 'italic';
+  /** Absolute line height in CSS pixels from `a:spcPts`. */
+  lineHeight?: number;
+  /** Relative line height from `a:spcPct`. */
+  lineHeightRatio?: number;
+  /** Absolute spacing after a paragraph in CSS pixels. */
+  lineSpacingAfter?: number;
+  /** Relative spacing after a paragraph. */
+  lineSpacingAfterRatio?: number;
+  /** Text-body insets in CSS pixels. */
+  textInsetLeft?: number;
+  textInsetTop?: number;
+  textInsetRight?: number;
+  textInsetBottom?: number;
+  /** DiagramML text vertical anchor (`t`, `ctr`, or `b`). */
+  textVerticalAnchor?: string;
+  /** Independent DiagramML text-frame geometry from `dsp:txXfrm`. */
+  textFrameX?: number;
+  textFrameY?: number;
+  textFrameWidth?: number;
+  textFrameHeight?: number;
+  /**
+   * 3D scene (camera/light rig/backdrop) from `dsp:spPr/a:scene3d`, when this
+   * cached shape carries its own per-shape camera. Bevel quick styles
+   * (Polished, Inset, Cartoon, Powder) cache one per shape (always
+   * `orthographicFront`, so the 2D layout stays undistorted). Scene quick
+   * styles (Brick, Flat, Metallic, Sunset, Bird's Eye) instead put ONE camera
+   * on the whole diagram (see `PptxSmartArtQuickStyle.scene3d`) and leave this
+   * undefined on every shape.
+   */
+  scene3d?: Pptx3DScene;
+  /**
+   * 3D extrusion/bevel/contour/material from `dsp:spPr/a:sp3d`. PowerPoint
+   * caches this fully resolved (from the quick style's per-label `dgm:sp3d`)
+   * on every shape for every non-flat quick style, bevel or scene alike.
+   */
+  shape3d?: Pptx3DShape;
+  /**
+   * Text-body 3D extrusion/bevel from `dsp:txBody/a:bodyPr/a:sp3d`. Rare:
+   * present when a quick style extrudes the label text itself off the shape
+   * face (e.g. Bird's Eye Scene: `extrusionH="28000"`), rather than only the
+   * shape body.
+   */
+  text3d?: Text3DStyle;
+  /**
+   * The presentation style label (`presStyleLbl`: `node1`, `revTx`,
+   * `sibTrans2D1`, ...) of the layout node a REGENERATED shape was laid out
+   * from, when the layout engine reports it. Picks the quick-style label
+   * whose 3D the shape takes; `undefined` on cached (parsed) shapes.
+   */
+  styleLabel?: string;
+}
+/**
+ * Complete parsed SmartArt data for a {@link SmartArtPptxElement}: the neutral
+ * {@link DiagramData} (bound to the pptx node, quick-style and layout-definition
+ * types) plus the package parts, cached drawing and save hints.
+ *
+ * @example
+ * ```ts
+ * const data: PptxSmartArtData = {
+ *   resolvedLayoutType: "hierarchy",
+ *   layout: "hierarchy",
+ *   colorScheme: "colorful1",
+ *   style: "moderate",
+ *   nodes: [
+ *     { id: "1", text: "CEO", children: [
+ *       { id: "2", text: "VP Marketing", parentId: "1" },
+ *     ]},
+ *   ],
+ * };
+ * // => satisfies PptxSmartArtData
+ * ```
+ */
+interface PptxSmartArtData extends DiagramData {
+  nodes: PptxSmartArtNode[];
+  /** Pre-computed shapes from `ppt/diagrams/drawing*.xml`. */
+  drawingShapes?: PptxSmartArtDrawingShape[];
+  /** Background and outline chrome from `dgm:bg` / `dgm:whole`. */
+  chrome?: PptxSmartArtChrome;
+  /** Quick style from `ppt/diagrams/quickStyles*.xml`. */
+  quickStyle?: PptxSmartArtQuickStyle;
+  /** Editable metadata from the related DiagramML layout definition. */
+  layoutDefinition?: PptxSmartArtLayoutDefinition;
+  /** Relationship ID for the diagram data part (for round-trip save). */
+  dataRelId?: string;
+  /** Relationship ID for the diagram layout part. */
+  layoutRelId?: string;
+  /** Relationship ID for the drawing part. */
+  drawingRelId?: string;
+  /** Relationship ID for the colours part. */
+  colorsRelId?: string;
+  /** Relationship ID for the quick-styles part. */
+  styleRelId?: string;
+  /**
+   * `uniqueId` of the built-in PowerPoint layout whose definition was applied by a layout swap
+   * (`ooxml-core/pptx/smartart-layouts`). Save writes that definition as the layout part.
+   */
+  builtinLayoutId?: string;
+  /** Internal save hint: the layout definition changed in the editor. */
+  layoutDirty?: boolean;
+  /** Internal save hint: typed layout-definition metadata changed. */
+  layoutDefinitionDirty?: boolean;
+  /** Internal save hint: quick-style definition metadata changed. */
+  quickStyleDirty?: boolean;
+  /** Internal save hint: color-transform definition metadata changed. */
+  colorTransformDirty?: boolean;
+  /** Internal save hint: cached drawing geometry or text changed in the editor. */
+  drawingDirty?: boolean;
+}
+//#endregion
+export { DiagramNodeTextParagraphItem as $, PptxSmartArtNode as A, DiagramNumericRule as At, PptxSmartArtTextRun as B, CustomGeometryPoint as Bt, PptxSmartArtIteratorAttributes as C, DiagramShapeAdjustment as Ct, PptxSmartArtLayoutNode as D, DiagramConstraintPointType as Dt, PptxSmartArtLayoutDefinition as E, DiagramConstraintOperator as Et, PptxSmartArtQuickStyleLabel as F, DiagramStyleIntensity as Ft, PptxSmartArtChrome as G, PptxCustomPathProperties as Gt, SmartArtLayout as H, CustomGeometrySegment as Ht, PptxSmartArtResolvedStyleRef as I, AdjustHandlePolar as It, DiagramLayoutPreset as J, PptxSmartArtRawBackgroundFill as K, PptxSmartArtShapeAdjustment as L, AdjustHandleXY as Lt, PptxSmartArtNumericRule as M, DiagramConnection as Mt, PptxSmartArtPresLayoutVars as N, DiagramLayoutType as Nt, PptxSmartArtLayoutNodeShape as O, DiagramConstraintRelationship as Ot, PptxSmartArtQuickStyle as P, DiagramNodeCustomLayout as Pt, DiagramNodeTextParagraph as Q, PptxSmartArtTextParagraph as R, ConnectionSite as Rt, PptxSmartArtHueDirection as S, DiagramLocalizedText as St, PptxSmartArtLayoutCategory as T, DiagramConstraint as Tt, SmartArtNodeCustomLayout as U, CustomGeometryTextRect as Ut, PptxSmartArtWhen as V, CustomGeometryRawData as Vt, SmartArtRoleColorList as W, GeometryAdjustmentHandle as Wt, DiagramNode as X, DiagramPresLayoutVars as Y, DiagramNodeStyle as Z, PptxSmartArtConstraintTarget as _, DiagramForEach as _t, SmartArtLayoutType as a, DiagramDefinitionCategory as at, PptxSmartArtDefinitionText as b, DiagramLayoutCategory as bt, PptxSmartArtChoose as c, DiagramHueDirection as ct, PptxSmartArtColorStyleLabel as d, DiagramResolvedStyleRef as dt, DiagramNodeTextRun as et, PptxSmartArtColorTransform as f, DiagramRoleColorList as ft, PptxSmartArtConstraintRelationship as g, DiagramChoose as gt, PptxSmartArtConstraintPointType as h, DiagramAlgorithmParameter as ht, SmartArtColorScheme as i, DiagramColorTransformLabel as it, PptxSmartArtNodeStyle as j, DiagramColorScheme as jt, PptxSmartArtLocalizedText as k, DiagramConstraintTarget as kt, PptxSmartArtColorApplicationMethod as l, DiagramQuickStyle as lt, PptxSmartArtConstraintOperator as m, DiagramLayoutNode as mt, PptxSmartArtData as n, DiagramColorListMetadata as nt, SmartArtStyle as o, DiagramDefinitionMetadata as ot, PptxSmartArtConstraint as p, DiagramLayoutDefinition as pt, DiagramData as q, PptxSmartArtDrawingShape as r, DiagramColorTransform as rt, PptxSmartArtAlgorithmParameter as s, DiagramDefinitionText as st, PptxSmartArtConnection as t, DiagramColorApplicationMethod as tt, PptxSmartArtColorListMetadata as u, DiagramQuickStyleLabel as ut, PptxSmartArtDefinitionCategory as v, DiagramIteratorAttributes as vt, PptxSmartArtLayoutAlgorithm as w, DiagramWhen as wt, PptxSmartArtForEach as x, DiagramLayoutNodeShape as xt, PptxSmartArtDefinitionMetadata as y, DiagramLayoutAlgorithm as yt, PptxSmartArtTextParagraphItem as z, CustomGeometryPath as zt };
+//# sourceMappingURL=smart-art-ENMMEbmW.d.ts.map