pptx-react-viewer 1.16.2 → 1.17.1

package/dist/usePresenterWindow-DToCijGy.d.ts

@@ -1,1619 +0,0 @@
-import { n, o, m, P, a, e, f, X, p, q, r, s, t, u, v, w, x, y, z, A, B, D, E, F, G, H, J, K, L, i, j, l, k, g, h } from './presentation-BfnrtJV1.js';
-import { RefObject } from 'react';
-import { e as CollaborationRole, C as CollaborationConfig } from './types-ui-NG29h55h.js';
-import { Awareness } from 'y-protocols/awareness';
-import { Doc } from 'yjs';
-
-/**
- * Built-in theme presets modelled after common PowerPoint themes.
- *
- * Each preset provides:
- * - A display name
- * - A 12-colour scheme (dk1, dk2, lt1, lt2, accent1-6, hlink, folHlink)
- * - A font scheme (major/heading + minor/body font families)
- *
- * These presets can be passed directly to
- * {@link PptxHandlerCore.switchTheme} or the React `useThemeSwitching` hook
- * to apply a complete theme in one step.
- *
- * @module pptx-types/theme-presets
- */
-
-/**
- * A complete theme preset that can be applied to a presentation.
- *
- * @example
- * ```ts
- * import { THEME_PRESETS } from "pptx-viewer-core";
- *
- * const office = THEME_PRESETS.find(p => p.id === "office");
- * await handler.switchTheme(office.colorScheme, office.fontScheme, office.name);
- * ```
- */
-interface PptxThemePreset {
-    /** Unique identifier for the preset. */
-    id: string;
-    /** Human-readable display name. */
-    name: string;
-    /** The 12-colour scheme. */
-    colorScheme: e;
-    /** Heading and body font families. */
-    fontScheme: f;
-}
-
-/**
- * SDK input types for the headless PPTX builder API.
- *
- * These types provide a simplified, ergonomic interface for creating
- * presentation elements programmatically. Internal types (PptxElement,
- * ShapeStyle, TextStyle) are the canonical model; these types are
- * convenience wrappers that get mapped to the internal model by
- * the builder functions.
- *
- * @module sdk/types
- */
-
-/** Position and size in pixels. Converted to EMU internally when needed. */
-interface ElementPosition {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    rotation?: number;
-}
-type FillInput = {
-    type: 'solid';
-    color: string;
-    opacity?: number;
-} | {
-    type: 'gradient';
-    angle?: number;
-    gradientType?: 'linear' | 'radial';
-    stops: Array<{
-        color: string;
-        position: number;
-        opacity?: number;
-    }>;
-} | {
-    type: 'pattern';
-    preset: string;
-    foreground?: string;
-    background?: string;
-} | {
-    type: 'image';
-    url: string;
-    mode?: 'stretch' | 'tile';
-} | {
-    type: 'none';
-};
-interface StrokeInput {
-    color?: string;
-    width?: number;
-    dash?: i;
-    opacity?: number;
-    join?: 'round' | 'bevel' | 'miter';
-    cap?: 'flat' | 'rnd' | 'sq';
-}
-interface ShadowInput {
-    color?: string;
-    blur?: number;
-    offsetX?: number;
-    offsetY?: number;
-    opacity?: number;
-}
-interface TextStyleInput {
-    fontSize?: number;
-    fontFamily?: string;
-    bold?: boolean;
-    italic?: boolean;
-    underline?: boolean;
-    strikethrough?: boolean;
-    color?: string;
-    alignment?: 'left' | 'center' | 'right' | 'justify';
-    verticalAlignment?: 'top' | 'middle' | 'bottom';
-    lineSpacing?: number;
-    spaceBefore?: number;
-    spaceAfter?: number;
-}
-interface TextSegmentInput {
-    text: string;
-    style?: Partial<TextStyleInput>;
-}
-interface TextOptions extends Partial<ElementPosition> {
-    fontSize?: number;
-    fontFamily?: string;
-    bold?: boolean;
-    italic?: boolean;
-    underline?: boolean;
-    strikethrough?: boolean;
-    color?: string;
-    alignment?: 'left' | 'center' | 'right' | 'justify';
-    verticalAlignment?: 'top' | 'middle' | 'bottom';
-    lineSpacing?: number;
-    fill?: FillInput;
-    stroke?: StrokeInput;
-    shadow?: ShadowInput;
-    opacity?: number;
-}
-interface ShapeOptions extends Partial<ElementPosition> {
-    fill?: FillInput;
-    stroke?: StrokeInput;
-    text?: string;
-    textStyle?: Partial<TextStyleInput>;
-    adjustments?: Record<string, number>;
-    shadow?: ShadowInput;
-    opacity?: number;
-}
-interface ImageOptions extends Partial<ElementPosition> {
-    altText?: string;
-    cropLeft?: number;
-    cropTop?: number;
-    cropRight?: number;
-    cropBottom?: number;
-    opacity?: number;
-}
-interface TableInput {
-    rows: TableRowInput[];
-    columnWidths?: number[];
-    style?: string;
-    bandRows?: boolean;
-    bandColumns?: boolean;
-    firstRow?: boolean;
-    lastRow?: boolean;
-    firstCol?: boolean;
-    lastCol?: boolean;
-}
-interface TableRowInput {
-    cells: TableCellInput[];
-    height?: number;
-}
-interface TableCellInput {
-    text: string;
-    style?: Partial<TextStyleInput>;
-    fill?: FillInput;
-    gridSpan?: number;
-    rowSpan?: number;
-}
-interface TableOptions extends Partial<ElementPosition> {
-}
-interface ChartSeriesInput {
-    name: string;
-    values: number[];
-    color?: string;
-}
-interface ChartInput {
-    series: ChartSeriesInput[];
-    categories: string[];
-    title?: string;
-    hasLegend?: boolean;
-    legendPosition?: 't' | 'b' | 'l' | 'r' | 'tr';
-    grouping?: 'clustered' | 'stacked' | 'percentStacked';
-}
-interface ChartOptions extends Partial<ElementPosition> {
-}
-interface ConnectorOptions extends Partial<ElementPosition> {
-    type?: 'straight' | 'bent' | 'curved';
-    stroke?: StrokeInput;
-    startArrow?: j;
-    endArrow?: j;
-    from?: {
-        elementId: string;
-        site: number;
-    };
-    to?: {
-        elementId: string;
-        site: number;
-    };
-}
-interface MediaOptions extends Partial<ElementPosition> {
-    autoPlay?: boolean;
-    loop?: boolean;
-    volume?: number;
-    trimStartMs?: number;
-    trimEndMs?: number;
-    posterFrame?: string;
-}
-interface GroupOptions extends Partial<ElementPosition> {
-}
-type BackgroundInput = {
-    type: 'solid';
-    color: string;
-} | {
-    type: 'gradient';
-    angle?: number;
-    stops: Array<{
-        color: string;
-        position: number;
-    }>;
-} | {
-    type: 'image';
-    source: string;
-};
-interface TransitionInput {
-    type: k;
-    duration?: number;
-    direction?: string;
-    advanceAfterMs?: number;
-}
-interface AnimationInput {
-    preset: g;
-    trigger?: h;
-    duration?: number;
-    delay?: number;
-}
-interface PresentationOptions {
-    /** Slide width in EMU. Default: 12192000 (16:9 widescreen). */
-    width?: number;
-    /** Slide height in EMU. Default: 6858000 (16:9 widescreen). */
-    height?: number;
-    /** Theme configuration. */
-    theme?: PresentationThemeInput;
-    /** Presentation title (stored in docProps/core.xml). */
-    title?: string;
-    /** Presentation author. */
-    creator?: string;
-    /**
-     * Number of blank slides to include in the initial presentation.
-     * Default: 0 (no slides). Slides use the "Blank" layout.
-     */
-    initialSlideCount?: number;
-}
-interface PresentationThemeInput {
-    name?: string;
-    colors?: {
-        dk1?: string;
-        lt1?: string;
-        dk2?: string;
-        lt2?: string;
-        accent1?: string;
-        accent2?: string;
-        accent3?: string;
-        accent4?: string;
-        accent5?: string;
-        accent6?: string;
-        hlink?: string;
-        folHlink?: string;
-    };
-    fonts?: {
-        majorFont?: string;
-        minorFont?: string;
-    };
-}
-
-/**
- * Fluent builder for constructing slides with elements.
- *
- * Provides a chainable API for adding elements, setting slide properties,
- * and building a complete {@link PptxSlide}.
- *
- * @module sdk/SlideBuilder
- */
-
-/**
- * Fluent builder for a single slide.
- *
- * @example
- * ```ts
- * const slide = new SlideBuilder(1)
- *   .addText("Hello World", { fontSize: 36, bold: true, x: 100, y: 50 })
- *   .addShape("roundRect", { fill: { type: "solid", color: "#4472C4" } })
- *   .setNotes("Remember to mention key points")
- *   .setBackground({ type: "solid", color: "#F5F5F5" })
- *   .build();
- * ```
- */
-declare class SlideBuilder {
-    private readonly slide;
-    /**
-     * @param slideNumber - 1-based slide number.
-     * @param layoutPath - Optional layout archive path.
-     * @param layoutName - Optional layout display name.
-     */
-    constructor(slideNumber: number, layoutPath?: string, layoutName?: string);
-    /** Add a text box to the slide. */
-    addText(text: string | TextSegmentInput[], options?: TextOptions): this;
-    /** Add a shape to the slide. */
-    addShape(shapeType: string, options?: ShapeOptions): this;
-    /** Add a connector (line) to the slide. */
-    addConnector(options?: ConnectorOptions): this;
-    /** Add an image to the slide. */
-    addImage(source: string, options?: ImageOptions): this;
-    /** Add a table to the slide. */
-    addTable(input: TableInput, options?: TableOptions): this;
-    /** Add a chart to the slide. */
-    addChart(chartType: l, input: ChartInput, options?: ChartOptions): this;
-    /** Add a media element (video or audio) to the slide. */
-    addMedia(mediaType: 'video' | 'audio', source: string, options?: MediaOptions): this;
-    /** Add a group of elements to the slide. */
-    addGroup(children: a[], options?: GroupOptions): this;
-    /** Add a pre-built element directly. */
-    addElement(element: a): this;
-    /** Set slide background. */
-    setBackground(bg: BackgroundInput): this;
-    /** Set slide transition. */
-    setTransition(input: TransitionInput): this;
-    /** Add an animation to an element on this slide. */
-    addAnimation(elementId: string, input: AnimationInput): this;
-    /** Set speaker notes. */
-    setNotes(text: string): this;
-    /** Mark the slide as hidden. */
-    setHidden(hidden: boolean): this;
-    /** Assign the slide to a section. */
-    setSection(name: string, id?: string): this;
-    /**
-     * Add a freeform shape from SVG path data.
-     *
-     * Creates a custom-geometry shape element using the provided SVG path
-     * string and appends it to the slide's element list.
-     *
-     * @param pathData - An SVG path data string (e.g. `"M 0 0 L 100 50 L 50 100 Z"`).
-     * @param options - Optional position, styling, and size overrides.
-     * @returns The builder instance for chaining.
-     *
-     * @example
-     * ```ts
-     * new SlideBuilder(1)
-     *   .addFreeform("M 0 0 C 33 0 66 100 100 100", {
-     *     stroke: { color: "#FF0000", width: 2 },
-     *   })
-     *   .build();
-     * ```
-     */
-    addFreeform(pathData: string, options?: ShapeOptions): this;
-    /**
-     * Add a pre-built element from any element builder (calls `.build()` for you).
-     *
-     * Accepts any object with a `build()` method that returns a {@link PptxElement},
-     * such as {@link TextBuilder}, {@link ShapeBuilder}, {@link ImageBuilder}, etc.
-     *
-     * @param builder - An element builder with a `.build()` method.
-     * @returns The builder instance for chaining.
-     *
-     * @example
-     * ```ts
-     * const title = TextBuilder.create("Hello").fontSize(36).bold();
-     * new SlideBuilder(1).addBuilderElement(title).build();
-     * ```
-     */
-    addBuilderElement(builder: {
-        build(): a;
-    }): this;
-    /**
-     * Remove an element by its ID.
-     *
-     * Filters out the element with the given ID from the slide's element list.
-     * If no element matches, the slide is left unchanged.
-     *
-     * @param elementId - The unique ID of the element to remove.
-     * @returns The builder instance for chaining.
-     *
-     * @example
-     * ```ts
-     * const slide = new SlideBuilder(1)
-     *   .addText("temp", { x: 0, y: 0 })
-     *   .removeElement("txt_abc123_1")
-     *   .build();
-     * ```
-     */
-    removeElement(elementId: string): this;
-    /**
-     * Get the current list of elements on this slide.
-     *
-     * Returns a readonly view of the elements array. Useful for inspecting
-     * what has been added so far during the build process.
-     *
-     * @returns A readonly array of the slide's current elements.
-     *
-     * @example
-     * ```ts
-     * const builder = new SlideBuilder(1).addText("Hi");
-     * console.log(builder.getElements().length); // 1
-     * ```
-     */
-    getElements(): readonly a[];
-    /**
-     * Get the number of elements on this slide.
-     *
-     * @returns The count of elements currently added to the slide.
-     *
-     * @example
-     * ```ts
-     * const builder = new SlideBuilder(1)
-     *   .addText("A").addText("B");
-     * console.log(builder.elementCount); // 2
-     * ```
-     */
-    get elementCount(): number;
-    /**
-     * Get the last added element (useful for getting its ID for animations).
-     *
-     * Returns `undefined` if the slide has no elements yet.
-     *
-     * @returns The most recently added element, or `undefined`.
-     *
-     * @example
-     * ```ts
-     * const builder = new SlideBuilder(1).addShape("rect");
-     * const shape = builder.getLastElement();
-     * if (shape) {
-     *   builder.addAnimation(shape.id, { preset: "fadeIn" });
-     * }
-     * ```
-     */
-    getLastElement(): a | undefined;
-    /**
-     * Set the slide name/title for organizational purposes.
-     *
-     * Stores an arbitrary name string on the slide object. This is useful
-     * for labeling slides in tooling or custom workflows.
-     *
-     * @param name - The display name to assign to the slide.
-     * @returns The builder instance for chaining.
-     *
-     * @example
-     * ```ts
-     * new SlideBuilder(1)
-     *   .setName("Introduction")
-     *   .addText("Welcome!")
-     *   .build();
-     * ```
-     */
-    setName(name: string): this;
-    /** Return the built {@link PptxSlide}. */
-    build(): P;
-}
-
-/**
- * Factory for creating PPTX presentations from scratch.
- *
- * Generates a minimal valid OpenXML package (ZIP) containing all
- * required parts (presentation.xml, theme, slide master, layouts,
- * content types, relationships, and document properties). The
- * generated package is then loaded by {@link PptxHandler} so that
- * all existing editing and save operations work transparently.
- *
- * @module sdk/PresentationBuilder
- */
-
-/** Result returned by {@link PresentationBuilder.create}. */
-interface PresentationBuilderResult {
-    /** Initialized handler ready for editing and saving. */
-    handler: PptxHandler;
-    /** Parsed presentation data. */
-    data: m;
-    /** Convenience slide builder factory. */
-    createSlide: (layoutName?: string) => SlideBuilder;
-}
-
-/**
- * Fluent interface for navigating and mutating a {@link PptxData} structure.
- * Provides method-chaining access to slides, elements, and notes.
- */
-interface IPptxXmlBuilder {
-    /** Navigate to a slide by zero-based index (Pascal-case alias). */
-    Slides(index: number): PptxSlideBuilder;
-    /** Navigate to a slide by zero-based index. */
-    slide(index: number): PptxSlideBuilder;
-    /** Navigate to a slide by zero-based index (plural alias). */
-    slides(index: number): PptxSlideBuilder;
-    /** Return the underlying presentation data. */
-    project(): m;
-}
-/**
- * Root builder of the fluent PPTX editing API.
- *
- * Wraps a {@link PptxData} object and provides chainable accessors
- * to navigate into slides, elements, and notes for in-place mutation.
- */
-declare class PptxXmlBuilder implements IPptxXmlBuilder {
-    /** The presentation data being mutated. */
-    private readonly data;
-    /** @param data - The presentation data to wrap. */
-    constructor(data: m);
-    /**
-     * Factory method to create a builder from presentation data.
-     * @param data - The presentation data to wrap.
-     * @returns A new {@link PptxXmlBuilder} instance.
-     */
-    static from(data: m): PptxXmlBuilder;
-    /** @inheritdoc */
-    Slides(index: number): PptxSlideBuilder;
-    /**
-     * Navigate to a slide by zero-based index.
-     * @param index - Zero-based slide index.
-     * @returns A {@link PptxSlideBuilder} for the requested slide.
-     * @throws Error if index is not an integer or is out of range.
-     */
-    slide(index: number): PptxSlideBuilder;
-    /** @inheritdoc */
-    slides(index: number): PptxSlideBuilder;
-    /** Return the underlying {@link PptxData}. */
-    project(): m;
-    /** Pascal-case alias for {@link project}. */
-    Project(): m;
-}
-/**
- * Fluent builder scoped to a single slide.
- * Provides navigation to the slide's elements and notes.
- */
-declare class PptxSlideBuilder {
-    /** The slide being operated on. */
-    private readonly slideValue;
-    /** Reference back to the root builder for chaining. */
-    private readonly rootBuilder;
-    /**
-     * @param slideValue - The slide data.
-     * @param rootBuilder - The parent builder.
-     */
-    constructor(slideValue: P, rootBuilder: PptxXmlBuilder);
-    /** Navigate to the slide's notes builder (getter). */
-    get Notes(): PptxSlideNotesBuilder;
-    /** Navigate to the slide's notes builder. */
-    notes(): PptxSlideNotesBuilder;
-    /** Navigate to the slide's elements builder. */
-    elements(): PptxSlideElementsBuilder;
-    /** Return the underlying slide data. */
-    project(): P;
-    /** Pascal-case alias for {@link project}. */
-    Project(): P;
-    /** Navigate back to the root builder. */
-    done(): PptxXmlBuilder;
-    /** Pascal-case alias for {@link done}. */
-    Done(): PptxXmlBuilder;
-}
-/**
- * Fluent builder for manipulating the elements array of a single slide.
- * Supports adding, removing, and updating elements by ID.
- */
-declare class PptxSlideElementsBuilder {
-    private readonly slideValue;
-    private readonly slideBuilder;
-    /**
-     * @param slideValue - The slide whose elements are being modified.
-     * @param slideBuilder - The parent slide builder for chaining.
-     */
-    constructor(slideValue: P, slideBuilder: PptxSlideBuilder);
-    /**
-     * Append an element to the slide's element list.
-     * @param element - The element to add.
-     * @returns This builder for chaining.
-     */
-    add(element: a): this;
-    /**
-     * Remove an element from the slide by its ID.
-     * @param elementId - The ID of the element to remove.
-     * @returns This builder for chaining.
-     */
-    removeById(elementId: string): this;
-    /**
-     * Update an element in-place by ID using a transform function.
-     * @param elementId - The ID of the element to update.
-     * @param updater - A function that receives the current element and returns the replacement.
-     * @returns This builder for chaining.
-     */
-    updateById(elementId: string, updater: (current: a) => a): this;
-    /** Return the current elements array. */
-    project(): a[];
-    /** Navigate back to the slide builder. */
-    done(): PptxSlideBuilder;
-}
-/**
- * Fluent builder for manipulating speaker notes on a single slide.
- * Supports adding, setting, clearing, and retrieving notes text.
- */
-declare class PptxSlideNotesBuilder {
-    private readonly slideValue;
-    private readonly slideBuilder;
-    /**
-     * @param slideValue - The slide whose notes are being modified.
-     * @param slideBuilder - The parent slide builder for chaining.
-     */
-    constructor(slideValue: P, slideBuilder: PptxSlideBuilder);
-    /**
-     * Append text to existing notes (separated by newline).
-     * @param text - The text to append.
-     * @returns This builder for chaining.
-     */
-    add(text: string): this;
-    /** Pascal-case alias for {@link add}. */
-    Add(text: string): this;
-    /**
-     * Replace all notes with the given text.
-     * @param text - The replacement notes text. Empty string clears notes.
-     * @returns This builder for chaining.
-     */
-    set(text: string): this;
-    /** Pascal-case alias for {@link set}. */
-    Set(text: string): this;
-    /** Remove all notes from the slide. */
-    clear(): this;
-    /** Pascal-case alias for {@link clear}. */
-    Clear(): this;
-    /** Return the current notes text, or `undefined` if none. */
-    get(): string | undefined;
-    /** Pascal-case alias for {@link get}. */
-    Get(): string | undefined;
-    /** Navigate back to the slide builder. */
-    done(): PptxSlideBuilder;
-    /** Pascal-case alias for {@link done}. */
-    Done(): PptxSlideBuilder;
-    /**
-     * Synchronize the `notesSegments` array from the plain-text notes string.
-     * Splits text on newlines and creates corresponding {@link TextSegment} entries
-     * with paragraph break markers between lines.
-     */
-    private syncSegmentsFromNotes;
-}
-
-interface PptxHandlerLoadOptions {
-    eagerDecodeImages?: boolean;
-    password?: string;
-    /**
-     * Maximum total uncompressed bytes accepted from the input ZIP archive.
-     * Defaults to 500 MiB. When the sum of `_data.uncompressedSize` across
-     * all archive entries exceeds this cap, `load()` rejects with a
-     * {@link ZipBombError}. A hard cap of 65 536 archive entries also
-     * applies.
-     */
-    maxUncompressedBytes?: number;
-    /**
-     * When `false` (default), relationship targets that resolve to
-     * `http://` or `https://` URLs are dropped from rendered slides
-     * (image, picture, background). Set to `true` to allow external image
-     * URLs to flow through to `<img src>`.
-     *
-     * Disabled by default to mitigate SSRF / privacy-leak vectors in
-     * server-side rendering and headless export pipelines.
-     */
-    allowExternalImages?: boolean;
-}
-/** Output format for the save pipeline. */
-type PptxSaveFormat = 'pptx' | 'ppsx' | 'pptm';
-interface PptxHandlerSaveOptions {
-    headerFooter?: r;
-    presentationProperties?: s;
-    customShows?: t[];
-    sections?: u[];
-    coreProperties?: v;
-    appProperties?: w;
-    customProperties?: x[];
-    /** Updated notes master data to save back to notesMaster1.xml. */
-    notesMaster?: y;
-    /** Updated handout master data to save back to handoutMaster1.xml. */
-    handoutMaster?: z;
-    /**
-     * Updated slide masters to save back to ppt/slideMasters/slideMaster*.xml.
-     * Each entry in the array applies typed mutations (clrMap, hf flags,
-     * background) to the master at its `path`. Masters not listed here pass
-     * through verbatim from the original load.
-     */
-    slideMasters?: A[];
-    /**
-     * Updated slide layouts to save back to ppt/slideLayouts/slideLayout*.xml.
-     * Each entry applies typed mutations (clrMapOverride, attrs, hf flags,
-     * background) to the layout at its `path`. Layouts not listed here pass
-     * through verbatim from the original load.
-     */
-    slideLayouts?: B[];
-    /** Updated tag collections to save back to ppt/tags/tag*.xml. */
-    tags?: D[];
-    /** Photo album metadata to save back to `p:photoAlbum`. */
-    photoAlbum?: E;
-    /** East Asian line-break settings to save back to `p:kinsoku`. */
-    kinsoku?: F;
-    /** Write-protection verifier. Set to `null` to remove, `undefined` to preserve existing. */
-    modifyVerifier?: G | null;
-    /** View properties to save back to ppt/viewProps.xml. */
-    viewProperties?: H;
-    /**
-     * Table style edits to save back to `ppt/tableStyles.xml`. Pass the
-     * `tableStyleMap` from `PptxData` (optionally with edited entries)
-     * to persist user edits. The `def` GUID and any unmodelled XML are
-     * preserved verbatim. Omitting the option round-trips the original
-     * part untouched.
-     */
-    tableStyles?: J;
-    /**
-     * Target output format.
-     * - `'pptx'` (default): Standard presentation.
-     * - `'ppsx'`: Slide-show file (opens in presentation mode).
-     * - `'pptm'`: Macro-enabled presentation (requires VBA data).
-     */
-    outputFormat?: PptxSaveFormat;
-    /**
-     * Embedded fonts to write back (or add) to the saved PPTX.
-     *
-     * Pass the `embeddedFonts` array from `PptxData` to preserve existing
-     * embedded fonts during save. You can also add new fonts by including
-     * entries with `rawFontData` populated.
-     *
-     * When omitted, the save pipeline will automatically re-embed any
-     * fonts that were loaded from the original PPTX and have `rawFontData`
-     * preserved (i.e. the default is lossless round-trip).
-     */
-    embeddedFonts?: K[];
-    /**
-     * OOXML conformance class for the saved output.
-     * - `'preserve'` (default): use the same conformance as the loaded file.
-     * - `'strict'`: force Strict Open XML (ISO/IEC 29500) namespace URIs.
-     * - `'transitional'`: force Transitional (ECMA-376) namespace URIs.
-     */
-    conformance?: 'strict' | 'transitional' | 'preserve';
-}
-interface IPptxHandlerRuntime {
-    /**
-     * Release all resources held by this runtime (Blob URLs, caches, ZIP).
-     * After calling, the runtime cannot be used further.
-     */
-    dispose(): void;
-    /**
-     * Revoke all Blob URLs created during image loading.
-     */
-    revokeBlobUrls(): void;
-    getCompatibilityWarnings(): n[];
-    getLayoutOptions(): o[];
-    createXmlBuilder(data: m): PptxXmlBuilder;
-    Builder(data: m): PptxXmlBuilder;
-    setTemplateBackground(path: string, backgroundColor: string | undefined): void;
-    setPresentationTheme(themePath: string, applyToAllMasters?: boolean): Promise<void>;
-    getTemplateBackgroundColor(path: string): string | undefined;
-    updateThemeColorScheme(colorScheme: e): Promise<void>;
-    updateThemeFontScheme(fontScheme: f): Promise<void>;
-    updateThemeName(name: string): Promise<void>;
-    applyTheme(colorScheme: e, fontScheme: f, themeName?: string): Promise<void>;
-    load(data: ArrayBuffer, options?: PptxHandlerLoadOptions): Promise<m>;
-    getChartDataForGraphicFrame(slidePath: string, graphicFrame: X | undefined): Promise<p | undefined>;
-    getSmartArtDataForGraphicFrame(slidePath: string, graphicFrame: X | undefined): Promise<q | undefined>;
-    getImageData(imagePath: string): Promise<string | undefined>;
-    /**
-     * Extract a media file from the PPTX archive as an ArrayBuffer.
-     * Returns undefined if the file is not found.
-     */
-    getMediaArrayBuffer(mediaPath: string): Promise<ArrayBuffer | undefined>;
-    save(slides: P[], options?: PptxHandlerSaveOptions): Promise<Uint8Array>;
-    exportSlides(slides: P[], options: L): Promise<Map<number, Uint8Array>>;
-    /**
-     * Get the available slide layouts for a specific slide, based on the
-     * slide's master. Scans the slide master's relationships to find all
-     * layouts that belong to it.
-     *
-     * @param slideIndex - Zero-based slide index.
-     * @param slides - Current slides array.
-     * @returns Array of layout options belonging to the same slide master.
-     */
-    getAvailableLayoutsForSlide(slideIndex: number, slides: P[]): Promise<o[]>;
-    /**
-     * Resolve the editable template (master + layout) elements a slide
-     * inherits, each carrying a `master-` / `layout-` prefixed id. Excludes
-     * placeholders; returns only decorative shapes/pictures/graphic frames.
-     *
-     * @param slideId - The slide's archive path (`PptxSlide.id`).
-     */
-    getTemplateElementsForSlide(slideId: string): Promise<a[]>;
-    /**
-     * Scan the loaded PPTX archive for all theme parts.
-     */
-    getAvailableThemes(): Promise<Array<{
-        path: string;
-        name?: string;
-    }>>;
-    /**
-     * Apply a different layout to an existing slide by updating the slide's
-     * relationship to point to the new layout and re-parsing layout
-     * placeholders / background.
-     *
-     * @param slideIndex - Zero-based slide index.
-     * @param layoutPath - Archive path of the target layout
-     *                     (e.g. `ppt/slideLayouts/slideLayout2.xml`).
-     * @param slides - Current slides array.
-     * @returns The updated slide with new layout path, name, and background.
-     */
-    applyLayoutToSlide(slideIndex: number, layoutPath: string, slides: P[]): Promise<P>;
-}
-
-/**
- * Abstract factory contract for creating {@link IPptxHandlerRuntime}
- * instances.
- *
- * Implement this interface to supply a custom runtime (e.g. a
- * WASM-backed or test-double runtime) to {@link PptxHandlerCore}.
- */
-interface IPptxHandlerRuntimeFactory {
-    /** Instantiate and return a new runtime implementation. */
-    createRuntime(): IPptxHandlerRuntime;
-}
-
-/**
- * Type definitions for OOXML encryption and decryption.
- *
- * Contains all interfaces and type aliases used by the OOXML crypto modules.
- *
- * @module ooxml-crypto-types
- */
-/** Supported encryption algorithms. */
-type EncryptionAlgorithm = 'AES128' | 'AES256';
-/** Encryption options for creating encrypted files. */
-interface EncryptionOptions {
-    /** The encryption algorithm to use (defaults to AES256). */
-    algorithm?: EncryptionAlgorithm;
-    /** Number of hash iterations for key derivation (defaults to 100000). Lower values speed up tests. */
-    spinCount?: number;
-}
-
-/**
- * Dependency injection options for {@link PptxHandlerCore}.
- *
- * Provide either `runtime` (an already-constructed runtime) or
- * `runtimeFactory` (a factory that will be called once). When neither
- * is supplied the default runtime is created automatically.
- *
- * @example
- * ```ts
- * // Use the default runtime:
- * const core = new PptxHandlerCore();
- *
- * // Inject a custom runtime:
- * const core = new PptxHandlerCore({ runtime: myRuntime });
- *
- * // Supply a factory for lazy creation:
- * const core = new PptxHandlerCore({ runtimeFactory: myFactory });
- * // => PptxHandlerCore instance with injected runtime
- * ```
- */
-interface PptxHandlerCoreDependencies {
-    runtime?: IPptxHandlerRuntime;
-    runtimeFactory?: IPptxHandlerRuntimeFactory;
-}
-/**
- * Thin facade over the PPTX runtime implementation.
- *
- * All heavy parsing, serialisation, and XML manipulation is delegated to an
- * {@link IPptxHandlerRuntime}. This surface stays stable and small so that
- * callers remain decoupled from the runtime internals and host-specific
- * runtime swaps (e.g. WASM vs Node) can be done transparently.
- *
- * @remarks
- * - Constructed once per open document.
- * - Errors from encrypted files are caught at `load()` time via
- *   {@link EncryptedFileError}.
- * - `PptxXmlBuilder` instances returned by `createXmlBuilder()` / `Builder()`
- *   operate directly on the runtime’s in-memory ZIP.
- *
- * @example
- * ```ts
- * const handler = new PptxHandlerCore();
- * const data    = await handler.load(arrayBuffer);
- * // ... mutate slides ...
- * const out     = await handler.save(data.slides);
- * // => Uint8Array of the modified .pptx file
- * ```
- */
-declare class PptxHandlerCore {
-    private readonly runtime;
-    /**
-     * Create a new handler, optionally injecting a custom runtime.
-     *
-     * Resolution order:
-     * 1. `dependencies.runtime` — use as-is.
-     * 2. `dependencies.runtimeFactory` — call `createRuntime()` once.
-     * 3. Fall back to {@link createDefaultPptxHandlerRuntime}.
-     *
-     * @param dependencies - Optional runtime or factory override.
-     *
-     * @example
-     * ```ts
-     * const core = new PptxHandlerCore();
-     * // => PptxHandlerCore instance with default runtime
-     * ```
-     */
-    constructor(dependencies?: PptxHandlerCoreDependencies);
-    /**
-     * Release all resources held by this handler instance.
-     *
-     * Revokes every Blob URL created for images/media, clears all
-     * in-memory caches, and releases the in-memory ZIP archive.
-     *
-     * Call this when the handler is no longer needed (e.g. component
-     * unmount) to free memory immediately rather than waiting for GC.
-     *
-     * After calling `dispose()`, do not call any other methods — create
-     * a new `PptxHandler` instance instead.
-     */
-    dispose(): void;
-    /**
-     * Return any compatibility warnings detected during the most recent load.
-     *
-     * Warnings indicate features the editor cannot fully represent (e.g.
-     * SmartArt, 3-D effects, embedded OLE objects).
-     *
-     * @returns Array of {@link PptxCompatibilityWarning} objects.
-     */
-    getCompatibilityWarnings(): n[];
-    /**
-     * Get the slide layout options available in the loaded presentation.
-     *
-     * Each option maps to a `<p:sldLayout>` inside the PPTX archive.
-     *
-     * @returns Array of {@link PptxLayoutOption} entries.
-     */
-    getLayoutOptions(): o[];
-    /**
-     * Create a fluent XML builder scoped to the given presentation data.
-     *
-     * The builder provides a chainable API for constructing and inserting
-     * OpenXML nodes directly into the runtime’s in-memory ZIP.
-     *
-     * @param data - The parsed {@link PptxData} to bind the builder to.
-     * @returns A new {@link PptxXmlBuilder} instance.
-     */
-    createXmlBuilder(data: m): PptxXmlBuilder;
-    /**
-     * Shorthand alias for {@link createXmlBuilder}.
-     *
-     * @param data - Parsed presentation data.
-     * @returns A {@link PptxXmlBuilder} instance.
-     */
-    Builder(data: m): PptxXmlBuilder;
-    /**
-     * Register a background image for a specific template layout path.
-     *
-     * @param path - The internal PPTX path (e.g. `ppt/slideLayouts/slideLayout1.xml`).
-     * @param backgroundColor - Optional hex colour to render behind the image.
-     */
-    setTemplateBackground(path: string, backgroundColor: string | undefined): void;
-    /**
-     * Retrieve the background colour previously set for a template layout.
-     *
-     * @param path - The internal PPTX layout path.
-     * @returns Hex colour string, or `undefined` if none was set.
-     */
-    getTemplateBackgroundColor(path: string): string | undefined;
-    /**
-     * Replace the presentation’s theme by loading an external `.thmx` file.
-     *
-     * @param themePath - Absolute or relative path to the `.thmx` file.
-     * @param applyToAllMasters - Apply to every slide master (default `true`).
-     *
-     * @example
-     * ```ts
-     * await handler.setPresentationTheme("./themes/corporate.thmx");
-     * // => void — theme XML replaced in the in-memory ZIP
-     * ```
-     */
-    setPresentationTheme(themePath: string, applyToAllMasters?: boolean): Promise<void>;
-    /**
-     * Modify the theme’s colour scheme (accent colours, background, text, etc.).
-     *
-     * @param colorScheme - A {@link PptxThemeColorScheme} with hex colour values.
-     *
-     * @example
-     * ```ts
-     * await handler.updateThemeColorScheme({
-     *   dk1: "#1A1A2E", dk2: "#16213E",
-     *   lt1: "#FFFFFF", lt2: "#E8E8E8",
-     *   accent1: "#0F3460", accent2: "#533483",
-     *   accent3: "#E94560", accent4: "#F0A500",
-     * });
-     * // => void — colour scheme updated in the in-memory theme XML
-     * ```
-     */
-    updateThemeColorScheme(colorScheme: e): Promise<void>;
-    /**
-     * Update the theme’s font scheme (heading + body typefaces).
-     *
-     * @param fontScheme - A {@link PptxThemeFontScheme} with font family names.
-     *
-     * @example
-     * ```ts
-     * await handler.updateThemeFontScheme({
-     *   majorFont: "Montserrat",
-     *   minorFont: "Open Sans",
-     * });
-     * // => void — font scheme updated in the in-memory theme XML
-     * ```
-     */
-    updateThemeFontScheme(fontScheme: f): Promise<void>;
-    /**
-     * Rename the presentation theme.
-     *
-     * @param name - New display name for the theme.
-     */
-    updateThemeName(name: string): Promise<void>;
-    /**
-     * Apply a complete theme in one call (colour scheme + font scheme + optional name).
-     *
-     * This is a convenience wrapper over {@link updateThemeColorScheme},
-     * {@link updateThemeFontScheme}, and {@link updateThemeName}.
-     *
-     * @param colorScheme - Colour definitions.
-     * @param fontScheme  - Font definitions.
-     * @param themeName   - Optional theme display name.
-     *
-     * @example
-     * ```ts
-     * await handler.applyTheme(
-     *   { dk1: "#000", lt1: "#FFF", accent1: "#0066CC", /* … *\/ },
-     *   { majorFont: "Helvetica", minorFont: "Arial" },
-     *   "Corporate 2025",
-     * );
-     * // => void — colour scheme, font scheme, and name applied atomically
-     * ```
-     */
-    applyTheme(colorScheme: e, fontScheme: f, themeName?: string): Promise<void>;
-    /**
-     * Switch the presentation's theme, updating both the underlying XML and
-     * re-resolving all element colours in-place.
-     *
-     * This is the high-level API for theme switching: it updates the theme
-     * data in the ZIP, then patches all resolved colours in the provided
-     * `PptxData` so that elements immediately reflect the new colour scheme
-     * without requiring a re-parse.
-     *
-     * @param data - The current parsed presentation data (mutated in-place for
-     *   convenience, but a new `PptxData` object is also returned).
-     * @param colorScheme - New colour scheme (12 colours).
-     * @param fontScheme - Optional new font scheme.
-     * @param themeName - Optional theme display name.
-     * @returns The updated PptxData with re-resolved colours.
-     *
-     * @example
-     * ```ts
-     * import { THEME_PRESETS } from "pptx-viewer-core";
-     *
-     * const ion = THEME_PRESETS.find(p => p.id === "ion")!;
-     * const newData = await handler.switchTheme(
-     *   data,
-     *   ion.colorScheme,
-     *   ion.fontScheme,
-     *   ion.name,
-     * );
-     * // => PptxData with all colours updated to the Ion theme
-     * ```
-     */
-    switchTheme(data: m, colorScheme: e, fontScheme?: f, themeName?: string): Promise<m>;
-    /**
-     * Apply a built-in theme preset to the presentation.
-     *
-     * Convenience wrapper around {@link switchTheme} that accepts a
-     * {@link PptxThemePreset} directly.
-     *
-     * @param data - The current parsed presentation data.
-     * @param preset - One of the built-in presets from {@link THEME_PRESETS}.
-     * @returns The updated PptxData.
-     *
-     * @example
-     * ```ts
-     * import { THEME_PRESETS } from "pptx-viewer-core";
-     *
-     * const preset = THEME_PRESETS.find(p => p.id === "facet")!;
-     * const newData = await handler.switchThemePreset(data, preset);
-     * ```
-     */
-    switchThemePreset(data: m, preset: PptxThemePreset): Promise<m>;
-    /**
-     * Parse a PPTX file from an `ArrayBuffer` and return structured data.
-     *
-     * If the file is encrypted and a `password` is provided in `options`,
-     * the file will be decrypted before parsing. If no password is provided
-     * for an encrypted file, throws {@link EncryptedFileError}.
-     *
-     * @param data    - Raw bytes of the `.pptx` file (may be encrypted OLE2).
-     * @param options - Optional load-time settings, including `password`.
-     * @returns Parsed {@link PptxData} containing slides, theme, layouts, etc.
-     *
-     * @example
-     * ```ts
-     * // Load an unencrypted file:
-     * const pptx = await handler.load(buf.buffer);
-     *
-     * // Load a password-protected file:
-     * const pptx = await handler.load(buf.buffer, { password: "secret" });
-     * console.log(`${pptx.slides.length} slides loaded`);
-     * ```
-     */
-    load(data: ArrayBuffer, options?: PptxHandlerLoadOptions): Promise<m>;
-    /**
-     * Extract chart data from a graphic-frame XML node.
-     *
-     * @param slidePath    - Internal archive path of the slide (e.g. `ppt/slides/slide1.xml`).
-     * @param graphicFrame - Parsed XML object for the `<p:graphicFrame>` node.
-     * @returns Chart data, or `undefined` if the frame is not a chart.
-     */
-    getChartDataForGraphicFrame(slidePath: string, graphicFrame: X | undefined): Promise<p | undefined>;
-    /**
-     * Extract SmartArt data from a graphic-frame XML node.
-     *
-     * @param slidePath    - Internal archive path of the slide.
-     * @param graphicFrame - Parsed XML object for the `<p:graphicFrame>` node.
-     * @returns SmartArt data, or `undefined` if the frame is not SmartArt.
-     */
-    getSmartArtDataForGraphicFrame(slidePath: string, graphicFrame: X | undefined): Promise<q | undefined>;
-    /**
-     * Get the base64-encoded data URL for an embedded image.
-     *
-     * @param imagePath - Archive-relative path (e.g. `ppt/media/image1.png`).
-     * @returns A `data:image/...;base64,...` string, or `undefined` if not found.
-     */
-    getImageData(imagePath: string): Promise<string | undefined>;
-    /**
-     * Extract a media file from the PPTX archive as an ArrayBuffer.
-     * Avoids the 33% base64 overhead of getImageData — prefer this for
-     * audio/video media that will be played via Blob URLs.
-     */
-    getMediaArrayBuffer(mediaPath: string): Promise<ArrayBuffer | undefined>;
-    /**
-     * Serialise current slides back into a PPTX byte array.
-     *
-     * @param slides  - The (possibly mutated) slide array.
-     * @param options - Optional save-time settings (e.g. thumbnail generation).
-     * @returns `Uint8Array` of the complete `.pptx` file.
-     *
-     * @example
-     * ```ts
-     * const bytes = await handler.save(data.slides);
-     * await fs.writeFile("output.pptx", Buffer.from(bytes));
-     * // => Uint8Array written to disk as a valid .pptx file
-     * ```
-     */
-    save(slides: P[], options?: PptxHandlerSaveOptions): Promise<Uint8Array>;
-    /**
-     * Serialise slides and then encrypt the output with a password.
-     *
-     * This is a convenience method that calls {@link save} followed by
-     * {@link encryptPptx}. The result is an OLE2 container suitable for
-     * opening in Microsoft PowerPoint with a password prompt.
-     *
-     * @param slides   - The (possibly mutated) slide array.
-     * @param password - The password to encrypt with.
-     * @param options  - Optional save-time and encryption settings.
-     * @returns `Uint8Array` of the encrypted OLE2 file.
-     *
-     * @example
-     * ```ts
-     * const bytes = await handler.saveEncrypted(data.slides, "secret");
-     * await fs.writeFile("protected.pptx", Buffer.from(bytes));
-     * // => Encrypted OLE2 file requiring password to open
-     * ```
-     */
-    saveEncrypted(slides: P[], password: string, options?: PptxHandlerSaveOptions & {
-        encryption?: EncryptionOptions;
-    }): Promise<Uint8Array>;
-    /**
-     * Get the slide layouts available for a specific slide.
-     *
-     * Returns layouts belonging to the same slide master as the given slide.
-     * This is useful for building a layout picker UI scoped to the current
-     * slide's master.
-     *
-     * @param slideIndex - Zero-based slide index.
-     * @param slides     - Current slides array.
-     * @returns Array of {@link PptxLayoutOption} entries for the slide's master.
-     *
-     * @example
-     * ```ts
-     * const layouts = await handler.getAvailableLayoutsForSlide(0, data.slides);
-     * console.log(layouts.map(l => l.name));
-     * // => ["Title Slide", "Title and Content", "Blank", ...]
-     * ```
-     */
-    getAvailableLayoutsForSlide(slideIndex: number, slides: P[]): Promise<o[]>;
-    /**
-     * Resolve the editable template (master + layout) elements a slide
-     * inherits, each carrying a `master-` / `layout-` prefixed id.
-     *
-     * This is the foundation for an "edit template/master" feature. The
-     * returned elements are the decorative master/layout shapes the loader
-     * already merges behind slide-authored content (master shapes behind,
-     * layout shapes on top); placeholders are excluded. The same elements are
-     * shared by every slide inheriting the layout/master, so editing one and
-     * saving updates the shared part.
-     *
-     * To persist an edit, keep the mutated template element inside the
-     * `slide.elements` array passed to {@link save}; the save writer reads
-     * template elements from there and writes their shape XML back into the
-     * owning layout/master `p:spTree`.
-     *
-     * @param slideId - The slide's archive path (the `PptxSlide.id`).
-     * @returns Master + layout elements with prefixed ids (may be empty).
-     *
-     * @example
-     * ```ts
-     * const templateEls = await handler.getTemplateElementsForSlide(slide.id);
-     * const logo = templateEls.find((e) => e.id.startsWith("master-"));
-     * if (logo) {
-     *   logo.x += 10;
-     *   slide.elements = [...slide.elements, logo];
-     *   await handler.save(data.slides);
-     * }
-     * ```
-     */
-    getTemplateElementsForSlide(slideId: string): Promise<a[]>;
-    /**
-     * Apply a different layout to an existing slide.
-     *
-     * Updates the slide's relationship to point to the new layout and
-     * refreshes layout-derived properties (background, layout name).
-     * The slide's own content elements are preserved.
-     *
-     * @param slideIndex - Zero-based slide index.
-     * @param layoutPath - Archive path of the target layout
-     *                     (e.g. `ppt/slideLayouts/slideLayout2.xml`).
-     * @param slides     - Current slides array (the slide at `slideIndex`
-     *                     is replaced in-place).
-     * @returns The updated {@link PptxSlide} with new layout metadata.
-     *
-     * @example
-     * ```ts
-     * const updated = await handler.applyLayoutToSlide(
-     *   0,
-     *   "ppt/slideLayouts/slideLayout3.xml",
-     *   data.slides,
-     * );
-     * console.log(updated.layoutName);
-     * // => "Two Content"
-     * ```
-     */
-    applyLayoutToSlide(slideIndex: number, layoutPath: string, slides: P[]): Promise<P>;
-    /**
-     * Scan the loaded PPTX archive for all theme parts (`ppt/theme/theme*.xml`)
-     * and return their paths and display names.
-     */
-    getAvailableThemes(): Promise<Array<{
-        path: string;
-        name?: string;
-    }>>;
-    /**
-     * Export selected slides as individual PPTX files.
-     *
-     * Each entry in the returned map is keyed by slide index and contains a
-     * standalone `Uint8Array` PPTX with only that slide.
-     *
-     * @param slides  - Full slide array.
-     * @param options - Export options (slide indexes, format, etc.).
-     * @returns A `Map<slideIndex, Uint8Array>` of exported files.
-     *
-     * @example
-     * ```ts
-     * const exports = await handler.exportSlides(data.slides, {
-     *   slideIndexes: [0, 2],
-     * });
-     * for (const [idx, bytes] of exports) {
-     *   await fs.writeFile(`slide_${idx}.pptx`, Buffer.from(bytes));
-     * }
-     * // => Map<number, Uint8Array> — one standalone .pptx per exported slide
-     * ```
-     */
-    exportSlides(slides: P[], options: L): Promise<Map<number, Uint8Array>>;
-}
-
-/**
- * Public facade for the PPTX editor handler.
- *
- * The implementation lives in `PptxHandlerCore` so this surface can stay small,
- * stable, and easy to replace with alternate implementations in the future.
- */
-declare class PptxHandler extends PptxHandlerCore {
-    /**
-     * Create a new blank PPTX presentation from scratch.
-     *
-     * This is a convenience static method that delegates to
-     * {@link PresentationBuilder.create}. The returned handler is fully
-     * initialized and ready for editing, adding slides, and saving.
-     *
-     * @param options - Optional slide dimensions, theme, and metadata.
-     * @returns Handler, parsed data, and a slide builder factory.
-     *
-     * @example
-     * ```ts
-     * const { handler, data, createSlide } = await PptxHandler.createBlank({
-     *   title: "My Deck",
-     *   theme: { colors: { accent1: "#FF6B6B" } },
-     * });
-     *
-     * data.slides.push(
-     *   createSlide("Blank")
-     *     .addText("Hello", { fontSize: 36 })
-     *     .build()
-     * );
-     *
-     * const bytes = await handler.save(data.slides);
-     * ```
-     */
-    static createBlank(options?: PresentationOptions): Promise<PresentationBuilderResult>;
-    /**
-     * Create a new PPTX presentation from scratch.
-     *
-     * Alias for {@link createBlank}. Generates a valid minimal OpenXML
-     * package and returns a fully initialized handler ready for editing,
-     * adding slides, and saving.
-     *
-     * @param options - Optional slide dimensions, theme, metadata,
-     *   and initial slide count.
-     * @returns Handler, parsed data, and a slide builder factory.
-     *
-     * @example
-     * ```ts
-     * const { handler, data, createSlide } = await PptxHandler.create({
-     *   title: "Q4 Report",
-     *   initialSlideCount: 3,
-     *   theme: { colors: { accent1: "#FF6B6B" } },
-     * });
-     *
-     * // The presentation already has 3 blank slides
-     * console.log(data.slides.length); // => 3
-     *
-     * // Add more slides with content
-     * data.slides.push(
-     *   createSlide("Blank")
-     *     .addText("Hello", { fontSize: 36 })
-     *     .build()
-     * );
-     *
-     * const bytes = await handler.save(data.slides);
-     * ```
-     */
-    static create(options?: PresentationOptions): Promise<PresentationBuilderResult>;
-}
-/** Supported merge shape operations (matching PowerPoint's Merge Shapes menu). */
-type MergeShapeOperation = 'union' | 'intersect' | 'subtract' | 'fragment' | 'combine';
-
-/**
- * Collaboration types: Shared type definitions for the real-time
- * collaboration infrastructure (Yjs-backed CRDT sync, presence tracking,
- * collaborative editing).
- *
- * @module collaboration/types
- */
-
-/** Connection lifecycle states for the Yjs WebSocket provider. */
-type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
-/**
- * Presence data broadcast to other participants.
- * Cursor position is relative to the slide canvas (0..canvasWidth, 0..canvasHeight).
- */
-interface UserPresence {
-    /** Unique client ID (assigned by Yjs awareness). */
-    clientId: number;
-    /** Sanitised display name. */
-    userName: string;
-    /** Optional avatar URL (validated). */
-    userAvatar?: string;
-    /** Hex colour for the user's cursor ring. */
-    userColor: string;
-    /** Slide index the user is currently viewing. */
-    activeSlideIndex: number;
-    /** Cursor X on the canvas (clamped to slide bounds). */
-    cursorX: number;
-    /** Cursor Y on the canvas (clamped to slide bounds). */
-    cursorY: number;
-    /** ISO timestamp of last update (for stale-presence cleanup). */
-    lastUpdated: string;
-    /** Optional currently selected element ID. */
-    selectedElementId?: string;
-    /** Role in the session (owner, viewer, or collaborator). */
-    role?: CollaborationRole;
-}
-/** Value exposed by `CollaborationContext`. */
-interface CollaborationContextValue {
-    /** Current WebSocket connection status. */
-    status: ConnectionStatus;
-    /** Presence data for all remote users (excludes the local user). */
-    remoteUsers: UserPresence[];
-    /** Broadcast the local user's presence state. */
-    broadcastPresence: (update: Partial<Omit<UserPresence, 'clientId'>>) => void;
-    /** Total number of connected users (including local). */
-    connectedCount: number;
-    /** The collaboration config that was provided. */
-    config: CollaborationConfig;
-    /** The Yjs document (for document sync). */
-    doc: Doc | null;
-    /**
-     * Whether the provider completed its initial document sync (or the
-     * first-write grace period elapsed). Local doc writes are gated on this.
-     */
-    synced: boolean;
-    /** Manually retry the WebSocket connection after a timeout or error. */
-    retry: () => void;
-}
-
-interface UseThemeSwitchingInput {
-    /** Ref to the PptxHandler instance. */
-    handlerRef: RefObject<PptxHandler | null>;
-    /** Current parsed presentation data (null when nothing is loaded). */
-    data: m | null;
-    /** Callback to update the presentation data after theme switch. */
-    onDataChange: (newData: m) => void;
-    /** Optional callback fired when theme switch completes successfully. */
-    onThemeChanged?: (preset: PptxThemePreset) => void;
-}
-interface ThemeSwitchingResult {
-    /** All available built-in theme presets. */
-    presets: readonly PptxThemePreset[];
-    /**
-     * Apply a theme preset to the current presentation.
-     * Updates both the in-memory ZIP and all resolved element colours.
-     */
-    switchToPreset: (preset: PptxThemePreset) => Promise<void>;
-    /**
-     * Apply a custom colour scheme (and optional font scheme) to the
-     * current presentation.
-     */
-    switchToCustom: (colorScheme: e, fontScheme?: f, themeName?: string) => Promise<void>;
-    /**
-     * Get the preset matching the current presentation theme (if any).
-     * Returns undefined if the current theme does not match a built-in preset.
-     */
-    currentPreset: PptxThemePreset | undefined;
-}
-/**
- * React hook providing theme switching capabilities for the PowerPoint viewer.
- *
- * @example
- * ```tsx
- * const { presets, switchToPreset, currentPreset } = useThemeSwitching({
- *   handlerRef,
- *   data,
- *   onDataChange: setData,
- * });
- *
- * return (
- *   <div>
- *     {presets.map(preset => (
- *       <button
- *         key={preset.id}
- *         onClick={() => switchToPreset(preset)}
- *         aria-pressed={preset.id === currentPreset?.id}
- *       >
- *         {preset.name}
- *       </button>
- *     ))}
- *   </div>
- * );
- * ```
- */
-declare function useThemeSwitching(input: UseThemeSwitchingInput): ThemeSwitchingResult;
-
-/**
- * useYjsProvider: Manages the Yjs document and provider lifecycle.
- *
- * Creates a Y.Doc and connects via one of two transports:
- *  - `websocket` (default): WebSocketProvider against `config.serverUrl`.
- *  - `webrtc`: peer-to-peer WebrtcProvider (no document server); usable from
- *    static hosting. Same-browser tabs sync over BroadcastChannel.
- * Exposes connection status and cleanup on unmount.
- *
- * This hook is intentionally thin: it only manages the transport layer.
- * Application-level collaboration logic lives in useCollaborativeState
- * and usePresenceTracking.
- *
- * @module collaboration/useYjsProvider
- */
-
-interface UseYjsProviderInput {
-    /**
-     * Collaboration config, or `undefined` when collaboration is inactive. The
-     * hook is always called (React hook rules) but stays fully dormant, never
-     * opening a transport, while config is absent.
-     */
-    config?: CollaborationConfig;
-}
-interface UseYjsProviderResult {
-    /** Current WebSocket connection status. */
-    status: ConnectionStatus;
-    /** The Yjs awareness instance (null until connected). */
-    awareness: Awareness | null;
-    /** The Yjs document (null until initialised). */
-    doc: Doc | null;
-    /** Local awareness client ID. */
-    clientId: number | null;
-    /**
-     * Whether the provider completed its initial document sync. Local doc
-     * writes should be gated on this so a late joiner never seeds its
-     * bootstrap deck into a room whose content has not arrived yet. Websocket
-     * flips it on the provider's 'synced' event; webrtc flips it on peer sync
-     * or after {@link INITIAL_SYNC_GRACE_MS} (a lone fresh-room peer never
-     * receives a sync event).
-     */
-    synced: boolean;
-    /** Manually retry the connection after a timeout or error. */
-    retry: () => void;
-}
-/**
- * Lazily loads `yjs` and `y-websocket`, creates a Y.Doc and
- * WebSocketProvider, and tracks the connection lifecycle.
- *
- * If the connection does not succeed within {@link CONNECTION_TIMEOUT_MS},
- * the provider is torn down and status moves to `'error'`. The consumer
- * can call `retry()` to attempt a fresh connection.
- *
- * The Yjs packages are dynamically imported so they are fully
- * tree-shaken when collaboration is not enabled.
- */
-declare function useYjsProvider({ config }: UseYjsProviderInput): UseYjsProviderResult;
-
-interface UsePresenceTrackingInput {
-    awareness: Awareness | null;
-    localClientId: number | null;
-    userName: string;
-    userColor: string;
-    userAvatar?: string;
-    /** Role in the session (broadcaster, viewer, or collaborator). */
-    role?: string;
-    canvasWidth: number;
-    canvasHeight: number;
-}
-interface UsePresenceTrackingResult {
-    /** Presence data for all remote users (excludes local). */
-    remoteUsers: UserPresence[];
-    /** Broadcast a partial presence update for the local user. */
-    broadcastPresence: (update: Partial<Omit<UserPresence, 'clientId'>>) => void;
-}
-declare function usePresenceTracking({ awareness, localClientId, userName, userColor, userAvatar, role, canvasWidth, canvasHeight, }: UsePresenceTrackingInput): UsePresenceTrackingResult;
-
-/**
- * useCollaborativeState: Composes the Yjs provider and presence tracking
- * into a single hook for the collaboration system.
- *
- * This is the primary hook consumed by the `CollaborationProvider` context.
- * It orchestrates:
- * - Yjs WebSocket connection lifecycle
- * - Presence tracking (broadcast + receive)
- * - Connection status
- *
- * @module collaboration/useCollaborativeState
- */
-
-interface UseCollaborativeStateInput {
-    /**
-     * Collaboration config, or `undefined` when collaboration is inactive. The
-     * hook is always called so the surrounding provider keeps a stable React
-     * tree shape; it produces a dormant value (no transport, empty presence)
-     * while config is absent.
-     */
-    config?: CollaborationConfig;
-    canvasWidth: number;
-    canvasHeight: number;
-}
-declare function useCollaborativeState({ config, canvasWidth, canvasHeight, }: UseCollaborativeStateInput): CollaborationContextValue | null;
-
-interface UseCollaborativeHistoryInput {
-    /** The local user's client ID (from Yjs awareness). */
-    localClientId: number | null;
-    /** Standard history undo function. */
-    handleUndo: () => void;
-    /** Standard history redo function. */
-    handleRedo: () => void;
-    /** Whether undo is available. */
-    canUndo: boolean;
-    /** Whether redo is available. */
-    canRedo: boolean;
-}
-interface UseCollaborativeHistoryResult {
-    /** Undo the last local change. */
-    handleUndo: () => void;
-    /** Redo the last undone local change. */
-    handleRedo: () => void;
-    /** Whether undo is available. */
-    canUndo: boolean;
-    /** Whether redo is available. */
-    canRedo: boolean;
-}
-declare function useCollaborativeHistory({ localClientId: _localClientId, handleUndo, handleRedo, canUndo, canRedo, }: UseCollaborativeHistoryInput): UseCollaborativeHistoryResult;
-
-/** Returns true if the current page was opened as an audience tab. */
-declare function isAudienceTab(): boolean;
-interface UsePresenterWindowInput {
-    currentSlideIndex: number;
-    isPresenterMode: boolean;
-    /** Raw PPTX bytes to share with the audience tab via IndexedDB. */
-    content?: ArrayBuffer | Uint8Array | null;
-}
-interface UsePresenterWindowResult {
-    openAudienceWindow: () => boolean;
-    closeAudienceWindow: () => void;
-    isAudienceWindowOpen: () => boolean;
-    syncSlideToAudience: (slideIndex: number) => void;
-}
-declare function usePresenterWindow(input: UsePresenterWindowInput): UsePresenterWindowResult;
-
-export { type ConnectionStatus as C, type MergeShapeOperation as M, PptxHandler as P, type ThemeSwitchingResult as T, type UserPresence as U, type CollaborationContextValue as a, type UseCollaborativeHistoryResult as b, type UseCollaborativeStateInput as c, type UsePresenceTrackingResult as d, type UseThemeSwitchingInput as e, useCollaborativeState as f, usePresenceTracking as g, useThemeSwitching as h, isAudienceTab as i, useYjsProvider as j, type PptxSaveFormat as k, type UseCollaborativeHistoryInput as l, type UsePresenceTrackingInput as m, type UsePresenterWindowInput as n, type UsePresenterWindowResult as o, type UseYjsProviderInput as p, type UseYjsProviderResult as q, usePresenterWindow as r, useCollaborativeHistory as u };