@shbernal/ts-pptx 3.2.0 → 3.4.0

package/dist/{presentation-Osx1cDdJ.d.ts → presentation-types-D7cgT-eG.d.ts}

@@ -1,6 +1,28 @@
-import { t as CustomPropertyValue } from "./pres-C-EU3SkN.js";
-import { c as ImportSlideMastersOptions, d as LayoutHandle, f as SlideSize, l as ImportSlideOptions, o as FromTemplateOptions, p as SlideSource, r as EmbeddedFontInfo, s as ImportShapeOptions, t as AppendSlidesOptions, u as ImportedSlideMaster } from "./presentation-types-Dj4riuDs.js";
+import { t as CustomPropertyValue } from "./pres-Dybf7ZUl.js";
 import { a as Part, i as Relationships, n as OpcPackage, o as Element, t as OpcInput } from "./package-CaOLXSNi.js";
+//#region src/embedded-fonts.d.ts
+/**
+ * The four face slots of `CT_EmbeddedFontListEntry`, in schema child order
+ * (`font` first, then these). Iterate in this order everywhere so the read- and
+ * write-side emitters agree on element order.
+ */
+declare const EMBEDDED_FONT_SLOTS: readonly ['regular', 'bold', 'italic', 'boldItalic'];
+type EmbeddedFontSlot = (typeof EMBEDDED_FONT_SLOTS)[number];
+/** One embeddable face: a slot plus the raw font bytes (absent in pure read-side merges). */
+interface EmbeddedFontFace {
+  slot: EmbeddedFontSlot;
+  bytes?: Uint8Array;
+}
+/** A typeface family with 1..4 embedded faces — one `p:embeddedFont` entry. */
+interface EmbeddedFont {
+  /** `p:font/@typeface` — MUST match the family name used in run/`fontFace` typefaces or PowerPoint won't bind it. */
+  typeface: string;
+  panose?: string;
+  pitchFamily?: number;
+  charset?: number;
+  faces: EmbeddedFontFace[];
+}
+//#endregion
 //#region src/read/oxml/theme.d.ts
 /**
  * The colour-resolution context: the two maps that turn a DrawingML colour
@@ -1121,10 +1143,16 @@ declare abstract class Shape {
   host: ShapeHost);
   /** Which concrete shape kind this is. */
   abstract readonly shapeType: ShapeType;
-  /** The transform element (`a:xfrm` or `p:xfrm`) carrying this shape's geometry, or `null` if inherited. */
-  protected abstract xfrm(): Element | null;
+  /**
+   * The transform element carrying this shape's geometry, or `null` if inherited.
+   *
+   * Defaults to `p:spPr/a:xfrm`, which is where three of the four shape kinds keep it
+   * (`p:sp`, `p:pic`, `p:cxnSp`). {@link GraphicFrame} overrides it: a `p:graphicFrame`
+   * has no `p:spPr` and carries a `p:xfrm` of its own directly.
+   */
+  protected xfrm(): Element | null;
   /** The transform element, creating it (and its container) in document order if absent. */
-  protected abstract getOrAddXfrm(): Element;
+  protected getOrAddXfrm(): Element;
   /**
    * Mark the owning host's part dirty so `save()` reserializes it. Public
    * because {@link element_} hands out the live DOM node: the hatch and the
@@ -1473,8 +1501,6 @@ declare abstract class Shape {
 /** An auto shape, text box, or placeholder (`p:sp`). The only kind that holds text. */
 declare class AutoShape extends Shape {
   readonly shapeType: 'autoShape';
-  protected xfrm(): Element | null;
-  protected getOrAddXfrm(): Element;
   get hasTextFrame(): boolean;
   get textFrame(): TextFrame | null;
   /**
@@ -1499,8 +1525,6 @@ declare class AutoShape extends Shape {
 declare class Picture extends Shape {
   #private;
   readonly shapeType: 'picture';
-  protected xfrm(): Element | null;
-  protected getOrAddXfrm(): Element;
   protected get supportsFill(): boolean;
   /** Relationship id of the embedded image (`p:blipFill/a:blip/@r:embed`), or `null`. */
   get imageRelId(): string | null;
@@ -1611,8 +1635,6 @@ declare class Picture extends Shape {
 declare class Connector extends Shape {
   #private;
   readonly shapeType: 'connector';
-  protected xfrm(): Element | null;
-  protected getOrAddXfrm(): Element;
   /**
    * The connector's **start**-point shape binding (`p:nvCxnSpPr/p:cNvCxnSpPr/a:stCxn`),
    * or `null` when the start point is unbound (a bare `p:cNvCxnSpPr`, i.e. a
@@ -1949,6 +1971,158 @@ declare class ChartExAxis {
   markDirty(): void;
 }
 //#endregion
+//#region src/read/api/diagram.d.ts
+/**
+ * `ST_PtType` — what a `dgm:pt` is.
+ *
+ * - `node` — a user-authored node, and the default when `@type` is absent.
+ * - `asst` — an assistant node (an org chart's off-branch box); user content too.
+ * - `doc` — the data model's single root; carries the layout/style/colour preset ids.
+ * - `pres` — generated by the layout engine to position a node; never user content.
+ * - `parTrans` / `sibTrans` — the two transition points of an edge, which a few layouts
+ *   (arrow processes, org-chart branches) let the user type a label into.
+ */
+type DiagramPointType = 'node' | 'asst' | 'doc' | 'pres' | 'parTrans' | 'sibTrans';
+/**
+ * `ST_CxnType` — what a `dgm:cxn` asserts. `parOf` (the default) is the parent/child edge of
+ * the user's tree; `presOf` and `presParOf` bind a node to the generated `pres` point that
+ * draws it, and are the layout engine's bookkeeping rather than structure.
+ */
+type DiagramConnectionType = 'parOf' | 'presOf' | 'presParOf' | 'unknownRelationship';
+/**
+ * One edge of a diagram's data model (`dgm:cxn`) — an attribute-only element, so it reads as
+ * plain data rather than as a proxy.
+ *
+ * The ids are `ST_ModelId` GUIDs matching a {@link DiagramPoint.modelId}. `parOf` edges are
+ * the tree a reader cares about: `sourceId` is the parent, `destinationId` the child, and
+ * `sourceOrder` the child's position among its siblings.
+ */
+interface DiagramConnection {
+  /** This edge's own id (`@modelId`). */
+  modelId: string | null;
+  /** What the edge asserts (`@type`); `parOf` when absent, its schema default. */
+  type: DiagramConnectionType;
+  /** The `@srcId` end — the parent, for a `parOf` edge. */
+  sourceId: string | null;
+  /** The `@destId` end — the child, for a `parOf` edge. */
+  destinationId: string | null;
+  /** The child's index among its siblings (`@srcOrd`). */
+  sourceOrder: number | null;
+  /** The parent's index as seen from the child (`@destOrd`). */
+  destinationOrder: number | null;
+  /** The `parTrans` point labelling this edge (`@parTransId`), or `null` when unset. */
+  parentTransitionId: string | null;
+  /** The `sibTrans` point labelling this edge (`@sibTransId`), or `null` when unset. */
+  siblingTransitionId: string | null;
+  /** The layout preset this edge belongs to (`@presId`), set on generated edges only. */
+  presentationId: string | null;
+}
+/** One point (`dgm:pt`) of a diagram's data model. */
+declare class DiagramPoint {
+  #private;
+  private readonly pt;
+  /** The diagram data part, so a text edit marks the right part dirty. */
+  private readonly part;
+  private readonly themeContext?;
+  private readonly relationships?;
+  constructor(pt: Element,
+  /** The diagram data part, so a text edit marks the right part dirty. */
+  part: Part, themeContext?: ThemeContext | undefined, relationships?: Relationships | undefined);
+  /** This point's id (`@modelId`), which connections reference. */
+  get modelId(): string | null;
+  /** What kind of point this is (`@type`); `node` when absent, its schema default. */
+  get type(): DiagramPointType;
+  /**
+   * For a transition point, the edge it labels (`@cxnId`), or `null`. The schema's default
+   * is the literal `0`, which means "none" rather than naming a point, so it reads `null`.
+   */
+  get connectionId(): string | null;
+  /**
+   * Whether this point is an unfilled prompt (`dgm:prSet/@phldr`) — a node PowerPoint draws
+   * with a grey placeholder string and treats as empty. Excluded from {@link Diagram.text}:
+   * a layout that stores its prompt in `dgm:t` would otherwise extract as content.
+   */
+  get isPlaceholder(): boolean;
+  /** The prompt string a placeholder point displays (`dgm:prSet/@phldrT`), or `null`. */
+  get placeholderText(): string | null;
+  /**
+   * This point's text body (`dgm:t`) as a {@link TextFrame}, or `null` when the point
+   * carries none. It is an `a:CT_TextBody` like any other, so `paragraphs`, `runs` and the
+   * `resolved*` getters all apply.
+   */
+  get textFrame(): TextFrame | null;
+  /** This point's text, paragraphs joined by `\n`; `''` when it carries none. */
+  get text(): string;
+  /** Escape hatch: the underlying `dgm:pt` element. After mutating it call {@link Diagram.markDirty}. */
+  get element_(): Element;
+}
+/** A SmartArt graphic frame's diagram, backed by its `dgm:dataModel` part. */
+declare class Diagram {
+  #private;
+  /** The diagram's data part (`/ppt/diagrams/data{N}.xml`), whose root is `dgm:dataModel`. */
+  readonly part: Part;
+  /** The frame's `dgm:relIds`, which names the other three parts by relationship id. */
+  private readonly relIds;
+  private readonly opc;
+  /** Relationships of the part holding the frame — what `dgm:relIds` resolves against. */
+  private readonly frameRelationships;
+  private readonly themeContext?;
+  constructor(
+  /** The diagram's data part (`/ppt/diagrams/data{N}.xml`), whose root is `dgm:dataModel`. */
+  part: Part,
+  /** The frame's `dgm:relIds`, which names the other three parts by relationship id. */
+  relIds: Element, opc: OpcPackage,
+  /** Relationships of the part holding the frame — what `dgm:relIds` resolves against. */
+  frameRelationships: Relationships, themeContext?: ThemeContext | undefined);
+  /** Partname of the diagram data part. */
+  get partName(): string;
+  /**
+   * Every point (`dgm:ptLst/dgm:pt`) in document order, unfiltered — generated `pres`
+   * points and the `doc` root included. Filter on {@link DiagramPoint.type} for the user's
+   * nodes; {@link text} is the shortcut for the common case.
+   */
+  get points(): DiagramPoint[];
+  /** Every edge (`dgm:cxnLst/dgm:cxn`) in document order. */
+  get connections(): DiagramConnection[];
+  /**
+   * The diagram's text in document order, blocks joined by `\n` — the counterpart to
+   * `TextFrame.text` for a construct that has no single text body.
+   *
+   * Contributing points are the ones a user can type into: everything except the generated
+   * `pres` points, the `doc` root, and any point flagged as an unfilled placeholder. A
+   * point with no text contributes no blank line. Transition labels (`parTrans`/`sibTrans`)
+   * are included where a layout has them, which is why this is not simply the node list.
+   */
+  get text(): string;
+  /**
+   * The layout preset the diagram is drawn with (the `doc` point's `dgm:prSet/@loTypeId`),
+   * e.g. `urn:microsoft.com/office/officeart/2005/8/layout/hList1`. This is what names the
+   * SmartArt *kind*; {@link layoutPart} is that preset's definition.
+   */
+  get layoutTypeId(): string | null;
+  /** The quick-style preset (the `doc` point's `dgm:prSet/@qsTypeId`). */
+  get quickStyleTypeId(): string | null;
+  /** The colour preset (the `doc` point's `dgm:prSet/@csTypeId`). */
+  get colorsTypeId(): string | null;
+  /** The layout definition part (`dgm:relIds/@r:lo`), or `null` when missing from the package. */
+  get layoutPart(): Part | null;
+  /** The quick-style part (`dgm:relIds/@r:qs`), or `null` when missing from the package. */
+  get quickStylePart(): Part | null;
+  /** The colours part (`dgm:relIds/@r:cs`), or `null` when missing from the package. */
+  get colorsPart(): Part | null;
+  /**
+   * The fallback drawing part (`dsp:drawing`) that renders the diagram for a consumer with
+   * no SmartArt layout engine, or `null` when the deck carries none. It is named by an MS
+   * extension on the data model rather than by `dgm:relIds`, so a slide holding two
+   * diagrams still resolves each to its own drawing.
+   */
+  get drawingPart(): Part | null;
+  /** Escape hatch: the underlying `dgm:dataModel` element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
+  get element_(): Element | null;
+  /** Mark the diagram data part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
+  markDirty(): void;
+}
+//#endregion
 //#region src/read/api/table-edit.d.ts
 /** The four edges plus the two diagonals, keyed as {@link TableCellEdge} names them. */
 declare const EDGE_QNAMES: {
@@ -2548,7 +2722,7 @@ declare class TableCell {
 }
 //#endregion
 //#region src/read/api/shapes/graphic-frame.d.ts
-/** A graphic frame (`p:graphicFrame`) — host for tables and charts. */
+/** A graphic frame (`p:graphicFrame`) — host for tables, charts and SmartArt diagrams. */
 declare class GraphicFrame extends Shape {
   #private;
   readonly shapeType: 'graphicFrame';
@@ -2561,6 +2735,18 @@ declare class GraphicFrame extends Shape {
   get hasChart(): boolean;
   /** Whether this frame hosts a chartEx chart (`a:graphicData/@uri` is the chartEx URI). */
   get hasChartEx(): boolean;
+  /** Whether this frame hosts a SmartArt diagram (`a:graphicData/@uri` is the diagram URI). */
+  get hasDiagram(): boolean;
+  /**
+   * The `a:graphicData/@uri` verbatim — the namespace naming what this frame hosts, or
+   * `null` when the frame carries no `a:graphicData`.
+   *
+   * Every `has*` predicate is a comparison against this, so a frame whose URI matches none
+   * of them is one the read model does not decode (an OLE object, an ink `p:contentPart`).
+   * Reading the URI is what lets a consumer say *which* construct it could not reach
+   * instead of inferring loss from four `false`s.
+   */
+  get graphicDataUri(): string | null;
   /** The hosted table, or `null` when this frame is not a table. */
   get table(): Table | null;
   /** The hosted chart, or `null` when this frame is not a chart or its part is missing. */
@@ -2571,6 +2757,12 @@ declare class GraphicFrame extends Shape {
    * `cx:chart` (not the classic `c:chart`), carrying the MS `chartEx` rel id.
    */
   get chartEx(): ChartEx | null;
+  /**
+   * The hosted SmartArt diagram, or `null` when this frame is not a diagram or its data
+   * part is missing. The payload child is `dgm:relIds`, which names four parts by
+   * relationship id; the `@r:dm` one is the data model this resolves.
+   */
+  get diagram(): Diagram | null;
 }
 //#endregion
 //#region src/read/api/shapes.d.ts
@@ -3272,9 +3464,14 @@ declare class Slide implements ShapeHost {
    * All text on the slide, flattened in document order — the read-model
    * counterpart to {@link TextFrame.text} one level up. Every text-bearing shape
    * contributes its text, recursing into groups ({@link GroupShape}) and reading
-   * table cells ({@link GraphicFrame.table}); text-free shapes (pictures,
-   * connectors, empty boxes) contribute nothing. Blocks are joined by `\n`; within
-   * a table, cells in a row are joined by `\t` and rows by `\n`.
+   * table cells ({@link GraphicFrame.table}) and SmartArt node text
+   * ({@link GraphicFrame.diagram}); text-free shapes (pictures, connectors, empty
+   * boxes) contribute nothing. Blocks are joined by `\n`; within a table, cells in
+   * a row are joined by `\t` and rows by `\n`.
+   *
+   * A diagram contributes for the same reason a table does: its nodes are body text
+   * PowerPoint itself searches and spell-checks, so a slide whose whole message is a
+   * SmartArt graphic would otherwise flatten to the empty string.
    *
    * This is deliberately scoped to the slide's own shape tree. It does **not**
    * include speaker notes (read those via {@link notesText}) or chart data labels
@@ -3435,6 +3632,29 @@ declare class Slide implements ShapeHost {
    * format is sniffed from the bytes unless `extension`/`contentType` are given.
    */
   addPicture(image: Uint8Array, options: AddPictureOptions): Picture;
+  /**
+     * Give this slide the speaker notes `text`, and return the resulting
+     * {@link NotesSlide}. A `
+` starts a new paragraph, matching the write-side
+     * `addNotes`; the runs carry no formatting of their own, so style them
+     * afterwards through {@link notesTextFrame}.
+     *
+     * The counterpart to the read side's `notesText`/`notesTextFrame`/`notesSlide`
+     * getters, and the way to annotate a slide that has **no notes part at all** —
+     * the state an `importSlide` without `{ importNotes: true }` leaves behind, and
+     * the one a `notesTextFrame` edit cannot reach because there is no frame to
+     * hand back. Calling it on a slide that already has notes replaces the body
+     * text and leaves the rest of the part (its geometry, its other two
+     * placeholders) alone.
+     *
+     * Creating the part pulls in what a notes slide must bind to: a `notesMaster`,
+     * of which a presentation may hold at most one. This deck's own is reused when
+     * it has one; otherwise one is installed, bound to a clone of this deck's theme
+     * so it resolves against the destination palette. That is the same
+     * single-master rule `importSlide({ importNotes: true })` and `appendSlides`
+     * follow, so mixing the three cannot produce a second notes master.
+     */
+  addNotes(text: string): NotesSlide;
   /**
    * @internal The slide's shape tree (`p:cSld/p:spTree`), or `null` if absent.
    * Exposed for cross-slide composition (`Presentation.importShape`).
@@ -3609,12 +3829,17 @@ declare class Presentation {
    * Duplicate the slide at `index` and insert the copy at `options.at` (deck
    * order; `0` = first), defaulting to appending at the end when `at` is omitted
    * or out of range. Returns the new slide. The new slide part copies the source
-   * bytes verbatim and shares the source's relationship targets (layout, images,
-   * …) by copying its `.rels`; a new presentation→slide relationship and a
-   * `p:sldId` entry are wired up. Marks the presentation part dirty.
+   * bytes verbatim and shares the source's deck-wide relationship targets
+   * (layout, images, media) by copying its `.rels`; a new presentation→slide
+   * relationship and a `p:sldId` entry are wired up. Marks the presentation part
+   * dirty.
    *
-   * Note: relationships are copied as-is, so a source slide that owns a
-   * one-to-one part (e.g. a notes slide) would end up shared with the clone.
+   * What the source page *owns* is copied rather than shared: its notes slide,
+   * charts, SmartArt diagrams and OLE embeddings, each with the subtree under it
+   * (a chart's embedded workbook comes along; the image inside its user-shapes
+   * drawing stays shared). PowerPoint refuses to open a deck where two slides
+   * resolve to one chart or diagram, so this is not tidiness — see
+   * `page-owned.ts` for the rule and the evidence behind it.
    */
   cloneSlide(index: number, options?: {
     at?: number;
@@ -3646,7 +3871,10 @@ declare class Presentation {
    * Only the layout(s) actually used by imported slides are copied; the imported
    * master's `p:sldLayoutIdLst` is pruned to exactly those, mirroring how
    * PowerPoint's "Reuse Slides" brings a slide across. Parts shared by repeated
-   * imports from the same source deck are copied once and reused.
+   * imports from the same source deck are copied once and reused — every part
+   * except the page itself. Importing the same source slide twice yields two
+   * independent copies over one shared layout/master/theme, which is what lets a
+   * deck show one page twice (verbatim, then edited).
    *
    * With `{ theme: 'preserve' }` the slide's source theme is instead *flattened*
    * into the slide XML and the slide is bound to this deck's existing
@@ -3660,6 +3888,53 @@ declare class Presentation {
    * widths). Source notes are dropped unless you pass `{ importNotes: true }`.
    */
   importSlide(source: Presentation, index: number, options?: ImportSlideOptions): Slide;
+  /**
+   * Import selected pages from one or more loaded source presentations as one
+   * batch. Each imported page lands at its `outputIndex` in the complete
+   * destination slide list after the batch, and the returned array is parallel
+   * to `requests` — `result[i]` is the page `requests[i]` asked for, whatever
+   * order the output positions were given in.
+   *
+   * Everything is checked before a single byte of this deck moves: every request
+   * names an existing source page, final output positions are unique, each source
+   * has this deck's slide size, and a read-only dry run of the copy proves every
+   * part it would reach is present. A batch therefore either applies in full or
+   * leaves this deck byte-identical, where a per-page loop of
+   * {@link importSlide} can leave a half-stitched deck behind.
+   *
+   * The batch also decides what a `slide → slide` link means: an internal link
+   * on a selected page must target another **selected** page (or one this deck
+   * already contains via an earlier import from that source), and is rewritten
+   * to the fresh partname — importing page 3 of 10 does not drag pages 1–2
+   * across as dependencies, and never strands the link. This mirrors
+   * `appendSlides`' `import/unresolved-slide-link`, which the write side already
+   * enforces for generator decks.
+   *
+   * One request is one output page, so naming the same source page in several
+   * requests is how you ask for several independent copies of it — the page part
+   * is the one thing an import never shares, exactly as in {@link importSlide}.
+   * Everything under it (layout, master, theme, media) is still copied once and
+   * shared. Where such a page is the target of a `slide → slide` link, the link
+   * resolves to one of its copies: pages duplicated together are copied in
+   * lockstep and link to their round-mates, and a link into a page requested only
+   * once always lands on that single copy.
+   *
+   * Speaker notes travel per request: `{ importNotes: true }` carries that page's
+   * `notesSlide` part across, wired to the new page and bound to a single
+   * `notesMaster` under the same 0..1 rule {@link importSlide} and
+   * {@link appendSlides} follow — the destination's own master wins when it has
+   * one. Notes are part of the up-front dry run too, so a batch that would fail
+   * carrying them is refused with the deck still byte-identical. A page named in
+   * several requests gets its own copy of its notes each time, as of everything
+   * else that page owns.
+   *
+   * Scope: pages come across under `'copy'` theme semantics (their own layout →
+   * master → theme subgraph, shared parts deduped via the copy registry).
+   * Embedded fonts are not carried, and sizes must match, since there is no batch
+   * spelling for `embedFonts` or `rescale`. Use {@link importSlide} when you need
+   * either of those.
+   */
+  importSlides(requests: readonly ImportSlidesRequest[]): Slide[];
   /**
    * Graft slide master(s) from another open package into this one and return what
    * was copied. Unlike {@link importSlide} — which brings a master across only as
@@ -3724,7 +3999,10 @@ declare class Presentation {
    *
    * Charts and internal slide-to-slide hyperlinks are carried across: chart parts
    * (chart XML + `.rels` + embedded workbook) are injected under fresh names, and a
-   * `slide:N` link is repointed at the Nth appended slide's new partname.
+   * `slide:N` link is repointed at the Nth appended slide's new partname. A chartEx
+   * (Office 2016 — waterfall, funnel, treemap, ...) chart carries too, as its own
+   * `chartEx{N}.xml` part behind the MS chartEx rel, with the style and color-style
+   * sidecars PowerPoint requires alongside it.
    *
    * The generator's presentation-level embedded fonts (`pptx.embedFont`) are also
    * carried into this deck and merged into its `p:embeddedFontLst`, de-duped by
@@ -3787,5 +4065,570 @@ declare class Presentation {
   save(): Promise<Uint8Array>;
 }
 //#endregion
-export { Chart as $, GroupShape as A, OuterShadow as At, Table as B, FillRect as Bt, CommentAuthor as C, CustomGeometry as Ct, NotesPlaceholder as D, InnerShadow as Dt, ModernCommentAuthor as E, Glow as Et, isPicture as F, SoftEdge as Ft, TableConditionFlags as G, ResolvedColor as Gt, TableCellBorderEdit as H, PictureFillTile as Ht, GraphicFrame as I, PatternFill as It, ChartExAxis as J, TableCellEdge as K, resolveColorElement as Kt, CellBorder as L, BackgroundFill as Lt, isConnector as M, RecolorColor as Mt, isGraphicFrame as N, Reflection as Nt, NotesSlide as O, LineEnd as Ot, isGroupShape as P, ShapeType as Pt, AxisNumberFormat as Q, CellBorders as R, BackgroundSource as Rt, Comment as S, ConnectionSite as St, ModernComment as T, GeometryCommand as Tt, TableRow as U, GradientFill as Ut, TableCell as V, PictureFill as Vt, ResolvedTableStyle as W, GradientStop as Wt, ChartExLegend as X, ChartExDataLabels as Y, ChartExSeries as Z, ThemeColorSlot as _, Run as _t, readCustomProperties as a, ChartSeries as at, Tag as b, AbsoluteFrame as bt, Slide as c, AutoShape as ct, TransitionSpeed as d, AutofitMode as dt, ChartAxis as et, ColorMapToken as f, BodyProperties as ft, Theme as g, Paragraph as gt, SlideMaster as h, LineSpacing as ht, readCoreProperties as i, ChartLine as it, isAutoShape as j, Recolor as jt, AnyShape as k, LineEnds as kt, TransitionInfo as l, Shape as lt, SlideLayout as m, BulletStyle as mt, CoreProperties as n, ChartFill as nt, AddPictureOptions as o, Connector as ot, Placeholder as p, BulletDetail as pt, ChartEx as q, ColorContext as qt, CustomProperty as r, ChartLegend as rt, AddTextBoxOptions as s, Picture as st, Presentation as t, ChartDataLabels as tt, TransitionInput as u, ShapeHost as ut, ThemeFontFace as v, RunHyperlink as vt, CommentSchema as w, CustomGeometryPath as wt, readTagsForPart as x, ChildFrame as xt, ThemeFontScheme as y, TextFrame as yt, CellThreeD as z, SlideBackground as zt };
-//# sourceMappingURL=presentation-Osx1cDdJ.d.ts.map
+//#region src/read/api/presentation-types.d.ts
+/** Slide dimensions, in both EMU (the OOXML unit) and inches. */
+interface SlideSize {
+  widthEmu: number;
+  heightEmu: number;
+  widthIn: number;
+  heightIn: number;
+}
+/**
+ * One `p:embeddedFont` entry, read from `presentation.xml`'s `p:embeddedFontLst`
+ * (see {@link Presentation.embeddedFonts}). A read-only view: it names the family
+ * and resolves each embedded face's `r:id` to the absolute partname of its binary
+ * `/ppt/fonts/*.fntdata` part, so a consumer can enumerate the embedded faces and
+ * pull their bytes without hand-parsing the presentation part or its rels.
+ */
+interface EmbeddedFontInfo {
+  /** `p:font/@typeface` — the family name PowerPoint binds the embed to. */
+  typeface: string;
+  /** `p:font/@panose`, or `null` when the entry declares none. */
+  panose: string | null;
+  /** The embedded faces, in `regular, bold, italic, boldItalic` schema order. */
+  faces: EmbeddedFontFaceInfo[];
+}
+/** One face of an {@link EmbeddedFontInfo}: which slot it fills and the part its `r:id` resolves to. */
+interface EmbeddedFontFaceInfo {
+  /** Which weight/style slot this face fills. */
+  slot: 'regular' | 'bold' | 'italic' | 'boldItalic';
+  /** Absolute partname of the face's binary `.fntdata` part (e.g. `/ppt/fonts/font1.fntdata`). */
+  partName: string;
+}
+/** Options for {@link Presentation.importSlide}. */
+interface ImportSlideOptions {
+  /**
+   * How the imported slide relates to themes.
+   *
+   * - `'copy'` (default): bring the slide's own `slideLayout → slideMaster →
+   *   theme` subgraph across, so the slide renders byte-for-byte as authored.
+   *   A deck stitched from N sources then carries N themes/masters.
+   * - `'preserve'`: *flatten then attach* — bake the source theme's colours and
+   *   style-matrix fills into the slide XML (so its pixels do not change), then
+   *   bind it to this deck's existing master/layout instead of importing the
+   *   source theme. The result is a single-theme file whose imported slides are
+   *   theme-independent: it fixes renderers that mis-resolve per-slide scheme
+   *   colours against the wrong (first) theme, and tidies the deck for handoff.
+   *
+   *   To stay faithful across the rebind, `preserve` also bakes the inheritance
+   *   the rebind would otherwise break explicitly onto the slide: the slide's
+   *   effective background; each placeholder's *inherited* geometry (`a:xfrm`
+   *   from the matching source layout/master placeholder) so it cannot shift or
+   *   clip; and each placeholder run's *inherited* colour and size/weight
+   *   (`sz`/`b`/`i`) from the source layout/master text styles. Typeface
+   *   (`a:latin`) is left to re-bind to the destination theme, like `fontRef`.
+   *   By default it does **not** carry decorative graphics that live on the source
+   *   master/layout shape tree (logos, accent shapes): those belong to the
+   *   master `preserve` deliberately drops. Set {@link carryMasterGraphics} to
+   *   bake them onto the slide instead.
+   * - `'restyle'`: re-brand to *this* deck. Rebind the slide to this deck's
+   *   master/layout exactly like `preserve` but **skip the flatten** — leave every
+   *   `a:schemeClr`, style-matrix ref (`fillRef`/`lnRef`/`effectRef`/`fontRef`),
+   *   and `p:bg` `bgRef` symbolic so they re-resolve against the *destination*
+   *   theme. The slide keeps its geometry, text, and structure but adopts this
+   *   deck's colours/fonts: `preserve` makes it "look the same everywhere",
+   *   `restyle` makes it "look like mine". The slide's own `p:clrMapOvr` is dropped
+   *   so the destination master's `clrMap` governs the re-brand.
+   *
+   *   **Load-bearing limitation:** `restyle` can only recolour what is *symbolic*.
+   *   Anything the source authored as a literal `a:srgbClr` has no theme reference
+   *   to re-resolve and stays exactly that colour, so a slide with a baked literal
+   *   palette re-brands little or nothing. Use `restyle` for slides built against
+   *   theme colours/style matrices, not hardcoded RGB — or set {@link remapLiterals}
+   *   to force-remap literals and copy table styles. Re-brand is inherently a
+   *   visual change (a source `accent1` light-on-dark can invert against a dark
+   *   destination `accent1`), so its output needs visual QA. A restyled table
+   *   resolves its `@tableStyleId` against the *destination* `tableStyles`; if the
+   *   destination lacks that id the table falls back (which {@link remapLiterals}
+   *   also addresses by copying the source style across).
+   */
+  theme?: 'copy' | 'preserve' | 'restyle';
+  /**
+   * `restyle` mode only. Push the re-brand past what symbolic references reach, for
+   * slides whose palette is partly hardcoded. When `true` it does two things the
+   * plain re-brand cannot:
+   *
+   * - **Literal colours** — every literal `a:srgbClr` equal to a *source*-theme
+   *   `clrScheme` slot is rewritten back to a symbolic `a:schemeClr` (routed through
+   *   the source `clrMap`), so it re-resolves against this deck's theme instead of
+   *   staying its authored RGB. A literal matching no source slot is left untouched.
+   * - **Table styles** — any `@tableStyleId` the slide references is copied from the
+   *   source `tableStyles.xml` into this deck's (same id, idempotent, leaving an id
+   *   the destination already defines alone), so a restyled table keeps its style
+   *   instead of falling back. The copied definition is itself symbolic, so it
+   *   re-brands to this deck's theme.
+   *
+   * Off by default: it deliberately reinterprets authored literals as theme colours,
+   * which is a visual change that needs QA. Ignored unless `theme` is `'restyle'`.
+   */
+  remapLiterals?: boolean;
+  /**
+   * `preserve`/`restyle` modes only. When `true`, bake the source
+   * `slideLayout`/`slideMaster` shape-tree decorations (everything on those shape
+   * trees *except* placeholders — logos, accent curves, footers drawn as shapes)
+   * onto the imported slide, behind its own content, so master/layout branding
+   * survives the rebind to this deck's master. Their media are copied across.
+   *
+   * Under `preserve` the carried decorations' theme references are flattened like
+   * the slide's own content; under `restyle` they are left symbolic and so
+   * re-brand to the destination palette along with the slide — note a carried
+   * source logo could recolour unexpectedly under a different palette.
+   *
+   * Off by default: it raises fidelity for cover/closer/divider slides at the
+   * cost of duplicating shapes that would otherwise live once on the shared
+   * master, so opt in only when that branding actually needs to travel with the
+   * slide. Ignored unless `theme` is `'preserve'` or `'restyle'`.
+   */
+  carryMasterGraphics?: boolean;
+  /**
+   * Zero-based insert position in `p:sldIdLst` (deck order). `0` makes the
+   * imported slide first; an `at` past the current slide count — or omitting it —
+   * appends. Use it to place brand bookends (cover at `0`, closer appended)
+   * around generator-authored interior slides regardless of import order.
+   */
+  at?: number;
+  /**
+   * Carry the *source deck's* embedded fonts (`p:embeddedFontLst` in its
+   * `presentation.xml`) into this deck, so an imported slide that renders with an
+   * embedded face keeps it on machines that lack the font. Off by default —
+   * fonts live on the presentation, not the slide, so they are only worth copying
+   * when you want the embed to travel.
+   *
+   * The font binary parts are copied under fresh `/ppt/fonts/` names (deduped via
+   * the per-source copy registry, so repeated imports copy each face once), the
+   * `application/x-fontdata` Default is added, and entries are merged into this
+   * deck's `p:embeddedFontLst` — de-duplicated by `typeface` + face slot, so a
+   * face this deck already embeds is reused rather than duplicated. The carry is a
+   * whole-deck operation (it copies *all* the source's embedded fonts, not just the
+   * faces this one slide uses), since the source list does not record which slide
+   * uses which face.
+   * @default false
+   */
+  embedFonts?: boolean;
+  /**
+   * What to do when the source slide size differs from this deck's. By default
+   * (`false`) `importSlide` throws on any mismatch. Set it to rescale the imported
+   * geometry onto this deck's canvas instead:
+   *
+   * - `'fit'` (or `true`): uniform scale by `min(sx, sy)` then center, so aspect
+   *   ratio is preserved (circles stay circles, rotations hold) and the slack on
+   *   the longer axis becomes a centered margin. Matches PowerPoint's "Ensure Fit".
+   * - `'stretch'`: independent per-axis scale so the content fills the canvas;
+   *   distorts shapes and cannot faithfully reposition rotated shapes. Matches
+   *   "Maximize".
+   *
+   * Only *geometry* is rescaled — every top-level shape/group/graphicFrame
+   * transform (`a:off`/`a:ext`) and table grid (`a:gridCol@w`, `a:tr@h`). Font
+   * sizes, line widths, and other absolute sizes are left as authored, so heavy
+   * down-scaling can leave text overflowing its (now smaller) box. In `copy` mode
+   * the imported layout and master shape trees are rescaled too, so inherited
+   * placeholder and background geometry stays aligned; in `preserve`/`restyle` the
+   * slide rebinds to this deck's master/layout (already the right size), so only
+   * the slide is touched.
+   * @default false
+   */
+  rescale?: boolean | 'fit' | 'stretch';
+  /**
+   * Carry the source slide's speaker notes across. By default (`false`) the
+   * `notesSlide` relationship is dropped, so the imported slide has no notes.
+   *
+   * When set, the source `notesSlide` is copied and wired to the imported slide.
+   * Its `slide` back-relationship is repointed at the new slide (the source slide
+   * is *not* copied). A presentation has at most one `notesMaster`: if this deck
+   * already has one, the imported notes reuse it (the source notesMaster and its
+   * theme are not copied); if it has none, the source notesMaster (and its theme)
+   * are copied and registered. The destination's notes styling therefore wins
+   * when both decks define one.
+   * @default false
+   */
+  importNotes?: boolean;
+}
+/** Options for {@link Presentation.importShape} / {@link Presentation.importShapes}. */
+interface ImportShapeOptions {
+  /**
+   * How the lifted shape relates to themes, mirroring {@link ImportSlideOptions}
+   * but scoped to one shape subtree:
+   *
+   * - `'preserve'` (default): bake the shape's scheme/style-matrix colours (and,
+   *   for a lifted placeholder, its inherited geometry/colour/size/anchor/list
+   *   style) to literals using the *source* slide's theme, so it keeps its look on
+   *   a host slide whose theme differs. A lifted placeholder is also *demoted* to a
+   *   plain shape (its `p:ph` stripped) once everything it inherited is baked, so it
+   *   neither re-resolves against the host's placeholder of the same type/idx nor
+   *   collides with it. The safe default for composing across decks.
+   * - `'restyle'`: leave the shape's theme references symbolic so it re-brands to
+   *   the host theme. Only *symbolic* colours re-brand — literal `a:srgbClr` the
+   *   source baked in stays put (same limitation as `importSlide` restyle).
+   * - `'copy'`: bring the shape's XML across untouched; only sane when the host
+   *   already shares the source theme.
+   *
+   * Unlike a slide import this never runs the slide-scoped background passes — a
+   * background belongs to a slide, not to a composed shape.
+   */
+  theme?: 'preserve' | 'restyle' | 'copy';
+  /** Override left edge (EMU). Omitted axes keep the shape's source `a:off`/`a:ext`. */
+  left?: number;
+  /** Override top edge (EMU). */
+  top?: number;
+  /** Override width (EMU); must be positive. */
+  width?: number;
+  /** Override height (EMU); must be positive. */
+  height?: number;
+  /**
+   * Insert position among the host shape tree's shape children (z-order, 0 =
+   * backmost). Out-of-range or omitted appends on top. A batch inserts in the
+   * given order starting at this position.
+   */
+  at?: number;
+  /**
+   * What to do when the source slide size differs from this deck's. Default
+   * (`false`/omitted) throws on any mismatch. Set it to rescale the lifted
+   * shape's geometry onto this deck's canvas instead (mirrors
+   * {@link ImportSlideOptions.rescale}, scoped to one shape):
+   *
+   * - `'fit'` (or `true`): uniform scale by `min(sx, sy)`, slack centered — the
+   *   shape keeps its aspect ratio (circles stay circles, rotations hold) and
+   *   lands at the position it would occupy on a centered copy of the source
+   *   canvas. Matches PowerPoint's "Ensure Fit".
+   * - `'stretch'`: independent per-axis scale; distorts. Matches "Maximize".
+   *
+   * Only *geometry* is rescaled — the shape/group/graphicFrame transform
+   * (`a:off`/`a:ext`) and any table grid (`a:gridCol@w`, `a:tr@h`). Font sizes,
+   * line widths, and other absolute sizes are left as authored, so heavy
+   * down-scaling can leave text overflowing its (now smaller) box. Explicit
+   * `left`/`top`/`width`/`height` overrides are applied *after* rescale and win.
+   * @default false
+   */
+  rescale?: boolean | 'fit' | 'stretch';
+  /**
+   * Carry the lifted shape's build animation across (default `false`). A shape's
+   * entrance/emphasis/exit build lives in the slide-scoped `p:timing`, not in the
+   * shape subtree, so it is dropped unless opted in. When set, the shape's effect
+   * click-group(s) and `<p:bldP>` are copied into the destination `p:timing`
+   * (created if absent), their `spid` references remapped to the shape's new id and
+   * their `<p:cTn>` ids renumbered to stay collision-free, and appended after any
+   * existing build — mirroring how PowerPoint merges a pasted shape's animation
+   * (see the `import-animation-merge` oracle). @default false
+   */
+  carryAnimation?: boolean;
+}
+/** A master brought across by {@link Presentation.importSlideMasters}. */
+interface ImportedSlideMaster {
+  /** Partname of the copied master in this (destination) package. */
+  partName: string;
+  /** Partnames of the layouts copied under it, in source `p:sldLayoutIdLst` order. */
+  layoutPartNames: string[];
+}
+/** Options for {@link Presentation.importSlideMasters}. */
+interface ImportSlideMastersOptions {
+  /**
+   * Pick which of the source's masters to graft. Receives the master's `p:cSld`
+   * `name` (`''` when unnamed) and its zero-based index in the source's
+   * `p:sldMasterIdLst`. Default: every master.
+   */
+  masters?: (name: string, index: number) => boolean;
+  /**
+   * Pick which layouts under each grafted master to bring. Receives the layout's
+   * `p:cSld` `name` and its zero-based index within that master's
+   * `p:sldLayoutIdLst`. Default: the whole family.
+   */
+  layouts?: (name: string, index: number) => boolean;
+  /**
+   * Require the source and destination slide sizes to match (default `true`).
+   * A grafted master is shipped into the layout gallery, not applied to existing
+   * slides — but a layout authored at a different canvas size shows up mis-scaled
+   * in that gallery, so the guard is on by default. Pass `false` to graft anyway.
+   */
+  requireEqualSize?: boolean;
+  /**
+   * Carry the *source deck's* embedded fonts (`p:embeddedFontLst` in its
+   * `presentation.xml`) into this deck, so a slide later bound to a grafted layout
+   * keeps that layout's embedded faces on machines that lack the font locally.
+   * Off by default — fonts live on the presentation, not the master, and copying
+   * them can add megabytes — so they are only worth carrying when you want the
+   * embed to travel with the gallery.
+   *
+   * Semantics are identical to {@link ImportSlideOptions.embedFonts}: binaries are
+   * copied under fresh `/ppt/fonts/` names (deduped via the per-source copy
+   * registry, so a re-call carries each face once), the `application/x-fontdata`
+   * Default is added, and entries merge into this deck's `p:embeddedFontLst`
+   * de-duplicated by `typeface` + face slot. The carry is a whole-deck operation —
+   * it copies *all* the source's embedded fonts, not only the faces the grafted
+   * masters use, since the source list does not record which face belongs to which
+   * master.
+   * @default false
+   */
+  embedFonts?: boolean;
+  /**
+   * Carry the *source deck's* table styles (`ppt/tableStyles.xml`) into this deck,
+   * so a table inserted on a grafted layout picks up the source's table styling
+   * instead of this deck's. Off by default: it rewrites an existing part rather than
+   * only adding new ones, so it is opt-in like {@link embedFonts}.
+   *
+   * Without it a grafted master's layouts arrive but its table styling does not, and
+   * a new table falls back to whatever default this deck carries — for a generated
+   * deck, a stub whose default is the standard *Medium Style 2 - Accent 1*. The
+   * mismatch is visible: the same table renders in a different accent than it would
+   * in the source deck.
+   *
+   * Styles union by `styleId` (a style this deck already defines wins, so a re-call
+   * is idempotent), while `a:tblStyleLst@def` — the default table style — is
+   * **source-wins**. Carrying the styles without the `def` would not fix the
+   * mismatch: the standard default GUID is one most templates *also* define, so the
+   * default would still resolve to the wrong style. The carry is whole-deck — it
+   * copies *all* the source's table styles, not only those the grafted masters use,
+   * since `tableStyles.xml` does not record which style belongs to which master.
+   * @default false
+   */
+  tableStyles?: boolean;
+  /**
+   * Move the grafted masters to the front of `p:sldMasterIdLst`, ahead of the ones
+   * this deck already had, keeping their import order. Off by default: which master
+   * leads is a statement about what the deck *is*, so it is the caller's call rather
+   * than a side effect of grafting.
+   *
+   * `p:sldMasterIdLst` order is not part of theme resolution — a slide resolves
+   * through its own layout's master, so this changes no existing slide's appearance.
+   * What it changes is the deck's identity in PowerPoint's UI: the list's first entry
+   * becomes `Designs(1)`, which is the theme the Design tab shows and the one
+   * Design ▸ Variants applies. Graft a brand master into a generated deck without
+   * this and the deck still presents as the generator's stock theme, because the
+   * stub master was there first.
+   *
+   * Reordering rewrites nothing but the list: relationships, ids, and every part
+   * outside `presentation.xml` are untouched, and a re-call is a no-op once the
+   * grafted masters already lead.
+   * @default false
+   */
+  primary?: boolean;
+}
+/** A layout in this deck's gallery, addressable as an {@link AppendSlidesOptions} target. */
+interface LayoutHandle {
+  /** Partname of the layout in this package (e.g. `/ppt/slideLayouts/slideLayout2.xml`). */
+  partName: string;
+  /** The layout's `p:cSld@name` (`''` when unnamed). */
+  name: string;
+  /** Partname of the master this layout belongs to. */
+  masterPartName: string;
+  /** Zero-based index of the master in `p:sldMasterIdLst`. */
+  masterIndex: number;
+  /** Zero-based index of the layout within its master's `p:sldLayoutIdLst`. */
+  layoutIndex: number;
+}
+/**
+ * One authored slide, extracted from a generator for injection into an existing
+ * package. The slide body XML references its media/hyperlinks by relationship id
+ * only, so {@link Presentation.appendSlides} preserves each `rId` and only
+ * repoints its target — see {@link SlideSource}.
+ */
+interface ExtractedSlide {
+  /** Standalone `<p:sld>` part body (XML declaration + namespaces included). */
+  xml: string;
+  /** Image media the body references, keyed by the `rId` used in {@link xml}. */
+  media: Array<{
+    rId: number;
+    bytes: Uint8Array;
+    extn: string;
+    contentType: string;
+  }>;
+  /** External hyperlink rels, keyed by the `rId` used in {@link xml}. */
+  hyperlinks: Array<{
+    rId: number;
+    target: string;
+  }>;
+  /**
+   * Charts the body references, keyed by the `rId` used in {@link xml}. Each carries
+   * the chart part XML and its embedded workbook bytes; the chart part's own `.rels`
+   * (workbook reference) is rebuilt by {@link Presentation.appendSlides}.
+   */
+  charts: ExtractedChart[];
+  /** Internal slide-to-slide links: the `rId` used in {@link xml} → 1-based source slide number. */
+  slideLinks: Array<{
+    rId: number;
+    sourceSlideNumber: number;
+  }>;
+  /**
+   * Embedded audio/video the body references. Each item is one media binary backed
+   * by two rels sharing a Target — the ECMA `audio`/`video` rel (`mediaRid`) and the
+   * MS-2007 `media` rel (`msMediaRid`) — plus a separate preview image rel
+   * (`previewRid`). {@link Presentation.appendSlides} reproduces this rel graph.
+   */
+  avMedia: AvMediaItem[];
+  /**
+   * Online (external-link) video the body references. Each item is two *external*
+   * rels sharing one link Target — the ECMA `video` rel (`mediaRid`) and the MS-2007
+   * `media` rel (`msMediaRid`) — with **no** media binary part. The poster frame is a
+   * normal image rel carried by {@link media}. {@link Presentation.appendSlides}
+   * wires the two external rels without reserving a media part or content type.
+   */
+  onlineMedia: OnlineMediaItem[];
+  /**
+   * The slide's speaker notes, or `undefined` when it has none. Carried as a ready
+   * `<p:notes>` part body plus its external hyperlink rels;
+   * {@link Presentation.appendSlides} creates the notes part, wires it to the appended
+   * slide, and binds it to a notes master (see {@link ExtractedSlides.notesMaster}).
+   */
+  notes?: ExtractedNotes;
+}
+/** One slide's speaker notes, extracted for {@link Presentation.appendSlides}. */
+interface ExtractedNotes {
+  /** Standalone `<p:notes>` part body (XML declaration + namespaces included). */
+  xml: string;
+  /**
+   * External hyperlink rels the notes body references, keyed by the `rId` used in
+   * {@link xml}. Notes rels reserve `rId1` for the notes master and `rId2` for the
+   * slide, so these start at `rId3`. Notes support external `url` links only.
+   */
+  hyperlinks: Array<{
+    rId: number;
+    target: string;
+  }>;
+}
+/**
+ * One chart extracted for {@link Presentation.appendSlides}, keyed by the `rId` the slide
+ * body uses to reference it.
+ *
+ * A classic (2007, `c:chartSpace`) chart is one part plus its embedded workbook. A chartEx
+ * (Office 2016 — waterfall, funnel, treemap, ...) chart is a different part in a different
+ * namespace, reached through a different relationship type, and PowerPoint reports it as
+ * corrupt without its two style sidecars — so {@link chartEx} carries them and its presence
+ * is what tells the two shapes apart.
+ */
+interface ExtractedChart {
+  /** Body `rId` of the slide's rel pointing at the chart part. */
+  rId: number;
+  /** The chart part body: `<c:chartSpace>` for a classic chart, `<cx:chartSpace>` for a chartEx one. */
+  chartXml: string;
+  /** The chart's embedded `.xlsx` workbook, the data source PowerPoint opens on edit. */
+  embeddingBytes: Uint8Array;
+  /**
+   * Present only for a chartEx chart, and then always with both sidecars. A chartEx part
+   * *requires* a chart-style and a color-style part or PowerPoint reports the deck as
+   * corrupt (`0x80070570`) — schema-valid but unopenable — so these are not optional and
+   * {@link Presentation.appendSlides} injects them alongside the chart part.
+   */
+  chartEx?: {
+    /** `cs:chartStyle` body for the chart's `style{N}.xml` part. */
+    styleXml: string;
+    /** `cs:colorStyle` body for the chart's `colors{N}.xml` part. */
+    colorsXml: string;
+  };
+}
+/** One embedded audio/video item extracted for {@link Presentation.appendSlides}. */
+interface AvMediaItem {
+  /** Whether the item is `audio` (`<a:audioFile>`) or `video` (`<a:videoFile>`). */
+  mtype: 'audio' | 'video';
+  /** Body `rId` of the ECMA `audio`/`video` rel (`r:link`); points at the media part. */
+  mediaRid: number;
+  /** Body `rId` of the MS-2007 `media` rel (`p14:media r:embed`); shares the media part Target. */
+  msMediaRid: number;
+  /** Body `rId` of the preview image rel (`a:blip r:embed` in the blipFill). */
+  previewRid: number;
+  /** The audio/video binary the media part will hold. */
+  mediaBytes: Uint8Array;
+  /** Media file extension (no dot), e.g. `mp4`, `mp3`. */
+  mediaExtn: string;
+  /** OPC content type for the media part (PowerPoint-authored, e.g. `audio/mpeg`). */
+  mediaContentType: string;
+  /** The preview/poster image bytes. */
+  previewBytes: Uint8Array;
+  /** Preview image extension (no dot), e.g. `png`. */
+  previewExtn: string;
+  /** OPC content type for the preview image part. */
+  previewContentType: string;
+}
+/** One online (external-link) video item extracted for {@link Presentation.appendSlides}. */
+interface OnlineMediaItem {
+  /** Body `rId` of the ECMA `video` rel (`a:videoFile r:link`); External, no part. */
+  mediaRid: number;
+  /** Body `rId` of the MS-2007 `media` rel (`p14:media r:link`); External, shares the link Target. */
+  msMediaRid: number;
+  /** The external video link both rels point at (`TargetMode="External"`). */
+  link: string;
+}
+/** A generator's authored slides + canvas size, the input to {@link Presentation.appendSlides}. */
+interface ExtractedSlides {
+  widthEmu: number;
+  heightEmu: number;
+  slides: ExtractedSlide[];
+  /**
+   * The generator's presentation-level embedded font faces (`pptx.embedFont`),
+   * carried into the destination deck by {@link Presentation.appendSlides}. Each
+   * face carries its raw `bytes`. Empty when the generator embeds no fonts.
+   */
+  embeddedFonts: EmbeddedFont[];
+  /**
+   * A notes master to fall back on, present only when at least one slide carries notes.
+   *
+   * A notes slide must bind to a notes master, and a destination template often has
+   * none — a deck authored without speaker notes carries no `notesMaster` part. So the
+   * generator's own notes master rides along, and {@link Presentation.appendSlides}
+   * installs it (with its theme) **only** when the destination has none. When the
+   * destination already has one, it wins and this is discarded — matching the
+   * `importNotes` policy, where the destination's notes styling also wins.
+   */
+  notesMaster?: {
+    xml: string;
+    themeXml: string;
+  };
+}
+/**
+ * Structural view of a slide producer (a `TsPptx` instance satisfies this).
+ * Kept structural so the read subsystem never imports the generator at runtime.
+ */
+interface SlideSource {
+  extractSlides(opts?: {
+    onMediaError?: 'throw' | 'placeholder';
+  }): Promise<ExtractedSlides>;
+}
+/** Options for {@link Presentation.appendSlides}. */
+interface AppendSlidesOptions {
+  /** Target layout to bind every appended slide to: by `p:cSld@name` or a {@link LayoutHandle}. */
+  layout: string | LayoutHandle;
+  /**
+   * Zero-based `p:sldIdLst` position for the first appended slide; subsequent
+   * slides follow it in order. Omitted/out-of-range appends at the end.
+   */
+  at?: number;
+  /** How `addImage` media errors surface during extraction (default `'throw'`). */
+  onMediaError?: 'throw' | 'placeholder';
+}
+/** One selected native source page and its final zero-based destination position. */
+interface ImportSlidesRequest {
+  /** Already-loaded source presentation whose immutable package bytes own the page. */
+  source: Presentation;
+  /**
+   * Zero-based source slide index. Naming one source page in several requests is
+   * how a batch asks for several independent copies of it.
+   */
+  sourceIndex: number;
+  /** Zero-based position in the complete destination slide list after this batch. */
+  outputIndex: number;
+  /**
+   * Carry this page's speaker notes (`notesSlideN.xml`) across, as
+   * `importSlide`'s {@link ImportSlideOptions.importNotes} does. Default false:
+   * the slide copy drops the `notesSlide` relationship, so the imported page
+   * arrives without notes.
+   *
+   * Per request rather than per batch because a stitch mixes sources — the
+   * notes of a library's cover page are worth carrying where a scratch deck's
+   * are not. The deck-wide half of the policy is not per request: a
+   * presentation holds at most one `notesMaster`, so the destination's own is
+   * reused when it has one and the first carried master is installed when it
+   * has none, exactly as `importSlide` and `appendSlides` do.
+   */
+  importNotes?: boolean;
+}
+/** Options for {@link Presentation.fromTemplate}. */
+interface FromTemplateOptions {
+  /**
+   * Keep a `.potx` main part's `…template.main+xml` content type instead of
+   * normalizing it to the editable `…presentation.main+xml` type. Off by default
+   * (the saved package opens as an editable deck, not a template). No effect on a
+   * `.pptx` input, whose main part is already editable.
+   */
+  keepTemplateContentType?: boolean;
+}
+//#endregion
+export { CellThreeD as $, ShapeType as $t, Theme as A, AutofitMode as At, ModernCommentAuthor as B, ChildFrame as Bt, TransitionInfo as C, ChartLine as Ct, Placeholder as D, AutoShape as Dt, ColorMapToken as E, Picture as Et, readTagsForPart as F, Paragraph as Ft, isAutoShape as G, Glow as Gt, NotesSlide as H, CustomGeometry as Ht, Comment as I, Run as It, isGroupShape as J, LineEnds as Jt, isConnector as K, InnerShadow as Kt, CommentAuthor as L, RunHyperlink as Lt, ThemeFontFace as M, BulletDetail as Mt, ThemeFontScheme as N, BulletStyle as Nt, SlideLayout as O, Shape as Ot, Tag as P, LineSpacing as Pt, CellBorders as Q, Reflection as Qt, CommentSchema as R, TextFrame as Rt, Slide as S, ChartLegend as St, TransitionSpeed as T, Connector as Tt, AnyShape as U, CustomGeometryPath as Ut, NotesPlaceholder as V, ConnectionSite as Vt, GroupShape as W, GeometryCommand as Wt, GraphicFrame as X, Recolor as Xt, isPicture as Y, OuterShadow as Yt, CellBorder as Z, RecolorColor as Zt, CustomProperty as _, AxisNumberFormat as _t, ExtractedSlides as a, FillRect as an, TableConditionFlags as at, AddPictureOptions as b, ChartDataLabels as bt, ImportSlideMastersOptions as c, GradientFill as cn, DiagramConnection as ct, ImportedSlideMaster as d, resolveColorElement as dn, DiagramPointType as dt, SoftEdge as en, Table as et, LayoutHandle as f, ColorContext as fn, ChartEx as ft, CoreProperties as g, ChartExSeries as gt, Presentation as h, ChartExLegend as ht, ExtractedSlide as i, SlideBackground as in, ResolvedTableStyle as it, ThemeColorSlot as j, BodyProperties as jt, SlideMaster as k, ShapeHost as kt, ImportSlideOptions as l, GradientStop as ln, DiagramConnectionType as lt, SlideSource as m, ChartExDataLabels as mt, EmbeddedFontFaceInfo as n, BackgroundFill as nn, TableCellBorderEdit as nt, FromTemplateOptions as o, PictureFill as on, TableCellEdge as ot, SlideSize as p, EmbeddedFontSlot as pn, ChartExAxis as pt, isGraphicFrame as q, LineEnd as qt, EmbeddedFontInfo as r, BackgroundSource as rn, TableRow as rt, ImportShapeOptions as s, PictureFillTile as sn, Diagram as st, AppendSlidesOptions as t, PatternFill as tn, TableCell as tt, ImportSlidesRequest as u, ResolvedColor as un, DiagramPoint as ut, readCoreProperties as v, Chart as vt, TransitionInput as w, ChartSeries as wt, AddTextBoxOptions as x, ChartFill as xt, readCustomProperties as y, ChartAxis as yt, ModernComment as z, AbsoluteFrame as zt };
+//# sourceMappingURL=presentation-types-D7cgT-eG.d.ts.map