@shbernal/ts-pptx 3.1.0 → 3.3.0

package/dist/{presentation-DyIRDKkp.d.ts → presentation-types-B50aOUFI.d.ts}

@@ -1,6 +1,28 @@
-import { t as CustomPropertyValue } from "./pres-BgvxhQ_m.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-Cb-1xDne.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
@@ -1084,13 +1106,41 @@ declare class TextFrame {
   markDirty(): void;
 }
 //#endregion
+//#region src/read/api/shapes/host.d.ts
+/** The part-level surface a {@link import('./base.js').Shape} resolves against. */
+interface ShapeHost {
+  /** The OPC part holding the shape tree (`p:sld` / `p:sldLayout` / `p:sldMaster`). */
+  readonly part: Part;
+  /** Partname of {@link part}. */
+  readonly partName: string;
+  /** The package the host belongs to, for reaching a referenced part (image, chart, …). */
+  readonly opc: OpcPackage;
+  /** {@link part}'s relationships — image embeds, hyperlinks, chart references. */
+  readonly relationships: Relationships;
+  /** The host's resolved colour/font context, backing every `resolved*` getter. */
+  themeContext(): ThemeContext;
+  /** The shape anywhere in this host's tree with the given drawing id, or `undefined`. */
+  shapeByIdDeep(id: number): AnyShape | undefined;
+}
+//#endregion
 //#region src/read/api/shapes/base.d.ts
-/** Common base for every shape in a slide's shape tree. */
+/** Common base for every shape in a shape tree — a slide's, a layout's, or a master's. */
 declare abstract class Shape {
   #private;
   protected readonly element: Element;
-  readonly slide: Slide;
-  constructor(element: Element, slide: Slide);
+  /**
+   * The part that owns this shape's tree — a `Slide`, a `SlideLayout`, or a
+   * `SlideMaster`. Narrow it with `instanceof` when you need the concrete class;
+   * {@link ShapeHost.partName} tells the tiers apart without one.
+   */
+  readonly host: ShapeHost;
+  constructor(element: Element,
+  /**
+   * The part that owns this shape's tree — a `Slide`, a `SlideLayout`, or a
+   * `SlideMaster`. Narrow it with `instanceof` when you need the concrete class;
+   * {@link ShapeHost.partName} tells the tiers apart without one.
+   */
+  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. */
@@ -1098,7 +1148,7 @@ declare abstract class Shape {
   /** The transform element, creating it (and its container) in document order if absent. */
   protected abstract getOrAddXfrm(): Element;
   /**
-   * Mark the owning slide part dirty so `save()` reserializes it. Public
+   * 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
    * obligation that comes with it belong on the same object.
    */
@@ -1340,20 +1390,20 @@ declare abstract class Shape {
   get lineEnds(): LineEnds | null;
   /**
    * The shape's outer drop shadow (`spPr/a:effectLst/a:outerShdw`), resolved
-   * against the slide theme, or `null` when the shape has no outer shadow. The
+   * against the host's theme, or `null` when the shape has no outer shadow. The
    * soft brand shadows the eye reads as "floating" panels live here and are
    * invisible in geometry/fill alone.
    */
   get shadow(): OuterShadow | null;
   /**
    * The shape's **inner** shadow (`spPr/a:effectLst/a:innerShdw`), resolved against
-   * the slide theme, or `null` when the shape has no inner shadow. The inset
+   * the host's theme, or `null` when the shape has no inner shadow. The inset
    * counterpart of {@link shadow}: the write-side `shadow: { type: 'inner' }`
    * emits it, and it is invisible in geometry/fill alone.
    */
   get innerShadow(): InnerShadow | null;
   /**
-   * The shape's glow halo (`spPr/a:effectLst/a:glow`), resolved against the slide
+   * The shape's glow halo (`spPr/a:effectLst/a:glow`), resolved against the host's
    * theme, or `null` when the shape has no glow. Same element the write-side text
    * glow emits, so its {@link Glow.radiusPt} and colour round-trip.
    */
@@ -1372,7 +1422,7 @@ declare abstract class Shape {
   /**
    * The shape's pattern (hatch) fill (`spPr/a:pattFill`), or `null` when the fill
    * is not a pattern. Surfaces the {@link PatternFill.preset} name and both
-   * colours resolved against the slide theme — the pattern counterpart of
+   * colours resolved against the host's theme — the pattern counterpart of
    * {@link resolvedFill}, which reports `null` for a non-solid fill and so drops a
    * hatched surface entirely.
    */
@@ -1388,7 +1438,7 @@ declare abstract class Shape {
    */
   get pictureFill(): PictureFill | null;
   /**
-   * The shape's solid fill resolved against the slide's theme
+   * The shape's solid fill resolved against the host's theme
    * ({@link Slide.themeContext}) to a literal hex — the resolved counterpart of
    * {@link fillColor}/{@link fillSchemeColor}, which report the raw reference.
    * `null` when the shape has no `a:solidFill` (a gradient/none/inherited fill)
@@ -1403,7 +1453,7 @@ declare abstract class Shape {
    */
   get resolvedFill(): ResolvedColor | null;
   /**
-   * The shape's line/border solid fill resolved against the slide's theme to a
+   * The shape's line/border solid fill resolved against the host's theme to a
    * literal hex — the resolved counterpart of {@link lineColor}/{@link lineSchemeColor}.
    * `null` when the shape has no `a:ln/a:solidFill` or it cannot be made literal.
    * Like {@link resolvedFill}, the result carries `effectiveHex` (the base colour
@@ -1433,8 +1483,8 @@ declare abstract class Shape {
    */
   get placeholder(): PlaceholderRef | null;
   /**
-   * Remove this shape from its parent (the slide's shape tree, or an enclosing
-   * group) and mark the owning slide part dirty. The proxy is dead afterwards.
+   * Remove this shape from its parent (the host's shape tree, or an enclosing
+   * group) and mark the owning host's part dirty. The proxy is dead afterwards.
    */
   delete(): void;
   /** Escape hatch: the underlying shape element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
@@ -1477,12 +1527,12 @@ declare class Picture extends Shape {
   /** Relationship id of the embedded image (`p:blipFill/a:blip/@r:embed`), or `null`. */
   get imageRelId(): string | null;
   /**
-   * Repoint the blip at a relationship id already present in the slide's
+   * Repoint the blip at a relationship id already present in the owning part's
    * relationships, without minting a new media part. The caller owns ensuring
    * the id exists and targets an image; use {@link setImage} to add fresh bytes.
    */
   set imageRelId(value: string);
-  /** Absolute partname of the embedded image, resolved via the slide's relationships, or `null`. */
+  /** Absolute partname of the embedded image, resolved via the owning part's relationships, or `null`. */
   get imagePartName(): string | null;
   /**
    * Relationship id of the embedded **vector (SVG)** image, read from the
@@ -1493,7 +1543,7 @@ declare class Picture extends Shape {
    * so a reader that wants the real drawn art must consult both.
    */
   get svgRelId(): string | null;
-  /** Absolute partname of the embedded SVG image, resolved via the slide's relationships, or `null`. */
+  /** Absolute partname of the embedded SVG image, resolved via the owning part's relationships, or `null`. */
   get svgPartName(): string | null;
   /**
    * Which drawable media this picture carries:
@@ -1548,7 +1598,7 @@ declare class Picture extends Shape {
   /**
    * Replace this picture's image with new bytes. Mints a fresh media part under
    * `/ppt/media/`, registers its content type, wires an `image` relationship
-   * from the owning slide, and repoints the blip's `@r:embed` at it.
+   * from the owning part, and repoints the blip's `@r:embed` at it.
    *
    * Copy-on-write: the previous media part is never mutated or removed, so any
    * other picture sharing it (common after `importSlide`/dedup) is unaffected;
@@ -2844,6 +2894,13 @@ declare class Theme {
  * and text style from. Geometry getters read the placeholder's *own* `a:xfrm`,
  * which a master/layout placeholder carries explicitly (so it round-trips, unlike a
  * notes placeholder's inherited geometry).
+ *
+ * This is the identity-and-geometry view. The same `p:sp` also appears in
+ * {@link SlideMaster.shapes} / {@link SlideLayout.shapes} as an `AutoShape`, which
+ * additionally carries the paint surface (`resolvedFill`, `resolvedLine`,
+ * `presetGeometry`, `rotation`, `absoluteFrame`) and reports its `p:ph` through
+ * `AutoShape.placeholder`. Read a placeholder here to *place* it; read it there to
+ * *draw* it.
  */
 declare class Placeholder {
   #private;
@@ -2888,20 +2945,25 @@ declare class Placeholder {
 /**
  * A deck's slide master (`slideMasterN.xml`) as a modeled object. Exposes the
  * property tiers a bound slide inherits: the {@link colorMap} (token → theme slot),
- * its {@link theme}, its {@link placeholders} (with geometry), its own
- * {@link background}, and the {@link layouts} that build on it. Reachable from
- * {@link SlideLayout.master} and `Slide.master`.
+ * its {@link theme}, its {@link shapes} and the {@link placeholders} subset of them,
+ * its own {@link background}, and the {@link layouts} that build on it. Reachable
+ * from {@link SlideLayout.master} and `Slide.master`.
  */
-declare class SlideMaster {
+declare class SlideMaster implements ShapeHost {
   #private;
-  private readonly opc;
+  /** The package the master belongs to, for reaching its layouts, theme, and media. */
+  readonly opc: OpcPackage;
   /** The master's OPC part (`/ppt/slideMasters/slideMasterN.xml`). */
   readonly part: Part;
-  constructor(opc: OpcPackage,
+  constructor(
+  /** The package the master belongs to, for reaching its layouts, theme, and media. */
+  opc: OpcPackage,
   /** The master's OPC part (`/ppt/slideMasters/slideMasterN.xml`). */
   part: Part);
   /** Partname of the master part. */
   get partName(): string;
+  /** This master part's relationships (its layouts, its theme, image embeds, …). */
+  get relationships(): Relationships;
   /** The master's authoring name (`p:cSld/@name`), or `''` when unnamed (the writer's default). */
   get name(): string;
   /** The master's theme (via its `theme` relationship), or `null` when absent. */
@@ -2913,6 +2975,18 @@ declare class SlideMaster {
    * A token the map omits reads `null`.
    */
   get colorMap(): Record<ColorMapToken, string | null>;
+  /**
+   * Every shape in the master's `p:cSld/p:spTree`, in document order — the same
+   * `AnyShape` union `Slide.shapes` returns, so shape-walking code applies
+   * unchanged. This is where a template's non-placeholder furniture lives: the
+   * header band, the rule under the title, the logo. Whether a given slide draws
+   * them is `Slide.showMasterSp` (and, for a layout, {@link SlideLayout.showMasterSp}).
+   *
+   * {@link placeholders} is the filtered view of the same tree.
+   */
+  get shapes(): AnyShape[];
+  /** The shape anywhere in the master's tree with the given drawing id, or `undefined`. */
+  shapeByIdDeep(id: number): AnyShape | undefined;
   /** The master's placeholder shapes (`p:sp` carrying a `p:ph`), in document order. */
   get placeholders(): Placeholder[];
   /** The layouts built on this master (via `p:sldLayoutIdLst` → its relationships), in list order. */
@@ -2933,19 +3007,24 @@ declare class SlideMaster {
  * A deck's slide layout (`slideLayoutN.xml`) as a modeled object — the gallery entry
  * a slide binds to. Exposes its {@link name}, its {@link type} (import-only; the
  * writer authors none), its {@link master} (and, through it, the {@link theme}), its
- * {@link placeholders} (with geometry), and its own {@link background}. Reachable
- * from `Slide.layout` and {@link SlideMaster.layouts}.
+ * {@link shapes} and the {@link placeholders} subset of them, and its own
+ * {@link background}. Reachable from `Slide.layout` and {@link SlideMaster.layouts}.
  */
-declare class SlideLayout {
+declare class SlideLayout implements ShapeHost {
   #private;
-  private readonly opc;
+  /** The package the layout belongs to, for reaching its master, theme, and media. */
+  readonly opc: OpcPackage;
   /** The layout's OPC part (`/ppt/slideLayouts/slideLayoutN.xml`). */
   readonly part: Part;
-  constructor(opc: OpcPackage,
+  constructor(
+  /** The package the layout belongs to, for reaching its master, theme, and media. */
+  opc: OpcPackage,
   /** The layout's OPC part (`/ppt/slideLayouts/slideLayoutN.xml`). */
   part: Part);
   /** Partname of the layout part. */
   get partName(): string;
+  /** This layout part's relationships (its master, image embeds, hyperlinks, …). */
+  get relationships(): Relationships;
   /** The layout's authoring name (`p:cSld/@name`, e.g. `Title and Content`), or `''` when unnamed. */
   get name(): string;
   /**
@@ -2954,10 +3033,31 @@ declare class SlideLayout {
    * authored deck reads `null`; an imported deck carries PowerPoint's value.
    */
   get type(): string | null;
+  /**
+   * Whether this layout draws the master's non-placeholder shapes
+   * (`p:sldLayout/@showMasterSp`). `xsd:boolean` defaulting to `true`, so an absent
+   * attribute means shown — the layout-tier counterpart of `Slide.showMasterSp`,
+   * and the one PowerPoint actually writes on a section-divider or full-bleed
+   * layout. A renderer resolving what to paint under a slide's own shapes has to
+   * consult both: the slide's flag, then its layout's.
+   */
+  get showMasterSp(): boolean;
   /** The master this layout is built on (via its `slideMaster` relationship), or `null` when absent. */
   get master(): SlideMaster | null;
   /** The theme this layout resolves against, via its {@link master}, or `null`. */
   get theme(): Theme | null;
+  /**
+   * Every shape in the layout's `p:cSld/p:spTree`, in document order — the same
+   * `AnyShape` union `Slide.shapes` returns, so shape-walking code applies
+   * unchanged. The write API authors non-placeholder shapes here: every
+   * `defineSlideMaster({ objects })` member that is not a `placeholder` (a `rect`,
+   * a `line`, an `image`, a `chart`, a `text` box) lands in this tree.
+   *
+   * {@link placeholders} is the filtered view of the same tree.
+   */
+  get shapes(): AnyShape[];
+  /** The shape anywhere in the layout's tree with the given drawing id, or `undefined`. */
+  shapeByIdDeep(id: number): AnyShape | undefined;
   /** The layout's placeholder shapes (`p:sp` carrying a `p:ph`), in document order. */
   get placeholders(): Placeholder[];
   /**
@@ -3060,7 +3160,7 @@ interface AddPictureOptions {
   /** MIME content type (e.g. `image/png`); sniffed alongside `extension` when omitted. */
   contentType?: string;
 }
-declare class Slide {
+declare class Slide implements ShapeHost {
   #private;
   readonly presentation: Presentation;
   /** The slide's OPC part (`/ppt/slides/slideN.xml`). */
@@ -3089,6 +3189,12 @@ declare class Slide {
   markDirty(): void;
   /** This slide part's relationships (image embeds, layout, hyperlinks, …). */
   get relationships(): Relationships;
+  /**
+   * The deck's OPC package. Convenience for `presentation.opc`, and the member
+   * {@link ShapeHost} names so a shape can reach a referenced part (an image, a
+   * chart) the same way whether it lives on a slide, a layout, or a master.
+   */
+  get opc(): OpcPackage;
   /**
    * The slide's resolved theme context (`clrMap` + `clrScheme` + the theme
    * `fmtScheme` + `fontScheme`, plus the layout/master roots), walked once from
@@ -3117,6 +3223,19 @@ declare class Slide {
    * Marks the slide part dirty.
    */
   set hidden(value: boolean);
+  /**
+   * Whether this slide draws the master's non-placeholder shapes
+   * (`p:sld/@showMasterSp`). `xsd:boolean` defaulting to `true`, so an absent
+   * attribute means shown — the same shape as {@link hidden}.
+   *
+   * This is the switch that decides whether {@link SlideMaster.shapes} belongs on
+   * *this* slide. A slide the author gave a full-bleed image or a section divider
+   * usually sets it to `0`, and a renderer that paints the master's band and logo
+   * anyway puts the template's furniture on top of a slide that deliberately hid
+   * it. Placeholders are unaffected: the flag suppresses only the master's
+   * decorative shapes.
+   */
+  get showMasterSp(): boolean;
   /**
    * The slide's show transition (`p:transition`), decoded into a typed model, or
    * `null` when the slide has none. Handles both PowerPoint forms: the bare
@@ -3338,6 +3457,29 @@ declare class Slide {
    * 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`).
@@ -3512,12 +3654,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;
@@ -3549,7 +3696,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
@@ -3563,6 +3713,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
@@ -3627,7 +3824,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
@@ -3690,5 +3890,570 @@ declare class Presentation {
   save(): Promise<Uint8Array>;
 }
 //#endregion
-export { Chart as $, GroupShape as A, Recolor as At, Table as B, PictureFill as Bt, CommentAuthor as C, CustomGeometryPath as Ct, NotesPlaceholder as D, LineEnd as Dt, ModernCommentAuthor as E, InnerShadow as Et, isPicture as F, PatternFill as Ft, TableConditionFlags as G, resolveColorElement as Gt, TableCellBorderEdit as H, GradientFill as Ht, GraphicFrame as I, BackgroundFill as It, ChartExAxis as J, TableCellEdge as K, ColorContext as Kt, CellBorder as L, BackgroundSource as Lt, isConnector as M, Reflection as Mt, isGraphicFrame as N, ShapeType as Nt, NotesSlide as O, LineEnds as Ot, isGroupShape as P, SoftEdge as Pt, AxisNumberFormat as Q, CellBorders as R, SlideBackground as Rt, Comment as S, CustomGeometry as St, ModernComment as T, Glow as Tt, TableRow as U, GradientStop as Ut, TableCell as V, PictureFillTile as Vt, ResolvedTableStyle as W, ResolvedColor as Wt, ChartExLegend as X, ChartExDataLabels as Y, ChartExSeries as Z, ThemeColorSlot as _, RunHyperlink as _t, readCustomProperties as a, ChartSeries as at, Tag as b, ChildFrame as bt, Slide as c, AutoShape as ct, TransitionSpeed as d, BodyProperties as dt, ChartAxis as et, ColorMapToken as f, BulletDetail as ft, Theme as g, Run as gt, SlideMaster as h, Paragraph as ht, readCoreProperties as i, ChartLine as it, isAutoShape as j, RecolorColor as jt, AnyShape as k, OuterShadow as kt, TransitionInfo as l, Shape as lt, SlideLayout as m, LineSpacing as mt, CoreProperties as n, ChartFill as nt, AddPictureOptions as o, Connector as ot, Placeholder as p, BulletStyle as pt, ChartEx as q, CustomProperty as r, ChartLegend as rt, AddTextBoxOptions as s, Picture as st, Presentation as t, ChartDataLabels as tt, TransitionInput as u, AutofitMode as ut, ThemeFontFace as v, TextFrame as vt, CommentSchema as w, GeometryCommand as wt, readTagsForPart as x, ConnectionSite as xt, ThemeFontScheme as y, AbsoluteFrame as yt, CellThreeD as z, FillRect as zt };
-//# sourceMappingURL=presentation-DyIRDKkp.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 $, SlideBackground as $t, Theme as A, Paragraph as At, ModernCommentAuthor as B, Glow as Bt, TransitionInfo as C, Shape as Ct, Placeholder as D, BulletDetail as Dt, ColorMapToken as E, BodyProperties as Et, readTagsForPart as F, ChildFrame as Ft, isAutoShape as G, Recolor as Gt, NotesSlide as H, LineEnd as Ht, Comment as I, ConnectionSite as It, isGroupShape as J, ShapeType as Jt, isConnector as K, RecolorColor as Kt, CommentAuthor as L, CustomGeometry as Lt, ThemeFontFace as M, RunHyperlink as Mt, ThemeFontScheme as N, TextFrame as Nt, SlideLayout as O, BulletStyle as Ot, Tag as P, AbsoluteFrame as Pt, CellBorders as Q, BackgroundSource as Qt, CommentSchema as R, CustomGeometryPath as Rt, Slide as S, AutoShape as St, TransitionSpeed as T, AutofitMode as Tt, AnyShape as U, LineEnds as Ut, NotesPlaceholder as V, InnerShadow as Vt, GroupShape as W, OuterShadow as Wt, GraphicFrame as X, PatternFill as Xt, isPicture as Y, SoftEdge as Yt, CellBorder as Z, BackgroundFill as Zt, CustomProperty as _, ChartLegend as _t, ExtractedSlides as a, ResolvedColor as an, TableConditionFlags as at, AddPictureOptions as b, Connector as bt, ImportSlideMastersOptions as c, EmbeddedFontSlot as cn, ChartExAxis as ct, ImportedSlideMaster as d, ChartExSeries as dt, FillRect as en, Table as et, LayoutHandle as f, AxisNumberFormat as ft, CoreProperties as g, ChartFill as gt, Presentation as h, ChartDataLabels as ht, ExtractedSlide as i, GradientStop as in, ResolvedTableStyle as it, ThemeColorSlot as j, Run as jt, SlideMaster as k, LineSpacing as kt, ImportSlideOptions as l, ChartExDataLabels as lt, SlideSource as m, ChartAxis as mt, EmbeddedFontFaceInfo as n, PictureFillTile as nn, TableCellBorderEdit as nt, FromTemplateOptions as o, resolveColorElement as on, TableCellEdge as ot, SlideSize as p, Chart as pt, isGraphicFrame as q, Reflection as qt, EmbeddedFontInfo as r, GradientFill as rn, TableRow as rt, ImportShapeOptions as s, ColorContext as sn, ChartEx as st, AppendSlidesOptions as t, PictureFill as tn, TableCell as tt, ImportSlidesRequest as u, ChartExLegend as ut, readCoreProperties as v, ChartLine as vt, TransitionInput as w, ShapeHost as wt, AddTextBoxOptions as x, Picture as xt, readCustomProperties as y, ChartSeries as yt, ModernComment as z, GeometryCommand as zt };
+//# sourceMappingURL=presentation-types-B50aOUFI.d.ts.map