/**
 * PptxRenderer — main API class for rendering PPTX files.
 *
 * Handles Wasm lifecycle, PPTX loading, SVG rendering, and export.
 */
import type { FontFallbackMap } from './font-fallbacks.js';
/** Options for text measurement callback. Font size is in CSS pixels (px). */
export interface MeasureTextFn {
    (text: string, fontFace: string, fontSizePx: number): number;
}
/** A comment on a slide. */
export interface SlideComment {
    authorId: number;
    date: string;
    index: number;
    text: string;
    x: number;
    y: number;
}
/** A comment author in the presentation. */
export interface CommentAuthor {
    id: number;
    name: string;
    initials: string;
}
/** Log level for controlling console output. */
export type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug';
/** Options for initializing PptxRenderer. */
export interface PptxRendererOptions {
    /** Custom text measurement function. If not provided, uses Canvas 2D (browser only). */
    measureText?: MeasureTextFn;
    /**
     * Custom font fallback mappings. Merged with built-in defaults (lib/font-fallbacks.ts).
     * User entries override built-in entries for the same font name.
     */
    fontFallbacks?: FontFallbackMap;
    /**
     * Log level for console output. Default: `'error'`.
     * - `'silent'`: No console output at all
     * - `'error'`:  Errors only (default)
     * - `'warn'`:   Errors + warnings
     * - `'info'`:   Errors + warnings + info messages
     * - `'debug'`:  All messages including debug details
     */
    logLevel?: LogLevel;
    /**
     * Maximum number of undo steps retained in the edit history. Default: `50`.
     * Older steps are discarded once the limit is exceeded. Set to `0` to disable
     * history (undo/redo become no-ops).
     */
    maxHistory?: number;
    /**
     * Date used to fill auto-updating date placeholders (`<a:fld type="datetime1">`).
     * Provide a fixed value for reproducible output (e.g. snapshot tests / exports).
     * Accepts a `Date`, a preformatted string, or a function returning either.
     * Default: the current date formatted via `toLocaleDateString()`.
     */
    currentDate?: Date | string | (() => Date | string);
}
/**
 * Result of an {@link PptxRenderer.undo} / {@link PptxRenderer.redo} call,
 * returned as a JSON string. `slides` lists the 0-indexed slides whose content
 * changed (so the caller can re-render just those); `slideCount` is the slide
 * count after the operation (changes when undoing/redoing add/delete slide).
 */
export interface HistoryResult {
    slides: number[];
    slideCount: number;
}
/** A single glyph box in {@link TextLayout} (EMU, absolute). */
export interface GlyphBox {
    x: number;
    w: number;
}
/** A run fragment box within a {@link TextLine} (EMU, absolute). */
export interface TextRunBox {
    paraIdx: number;
    runIdx: number;
    x: number;
    w: number;
    /** Char offset within the run where this box begins. */
    runCharStart: number;
    /** Char offset within the paragraph where this box begins. */
    paraCharStart: number;
    chars: GlyphBox[];
}
/** A visual line in {@link TextLayout} (EMU). */
export interface TextLine {
    paraIdx: number;
    y: number;
    h: number;
    runs: TextRunBox[];
}
/**
 * Text geometry returned by {@link PptxRenderer.getTextLayout} (parsed from JSON).
 * All coordinates are in EMU.
 */
export interface TextLayout {
    box: {
        x: number;
        y: number;
        cx: number;
        cy: number;
    };
    lines: TextLine[];
}
/**
 * A portable, self-contained shape spec for cross-slide (or cross-document)
 * copy/paste, produced by {@link PptxRenderer.getShapeSpec} and consumed by
 * {@link PptxRenderer.insertShapeSpec}. `xml` is the shape's OOXML fragment;
 * `media` carries any referenced images inline (base64) so the spec survives a
 * clipboard round-trip. (JSON-encoded as a string at the API boundary.)
 */
export interface ShapeSpec {
    xml: string;
    media: Array<{
        rid: string;
        ext: string;
        mime: string;
        b64: string;
    }>;
}
/** Caret position returned by {@link PptxRenderer.hitTestText} (parsed from JSON). */
export interface TextHit {
    paraIdx: number;
    runIdx: number;
    /** Char offset within the run. */
    charOffset: number;
    /** Char offset within the paragraph (use with `replaceTextRange`). */
    paraOffset: number;
}
/** Internal logger that respects log level. */
export interface Logger {
    debug(...args: unknown[]): void;
    info(...args: unknown[]): void;
    warn(...args: unknown[]): void;
    error(...args: unknown[]): void;
}
export declare class PptxRenderer {
    private wasm;
    /** Decompressed text ZIP entries (path → UTF-8 string) */
    private files;
    /** Raw binary ZIP entries (path → bytes) */
    private rawFiles;
    /** Original PPTX bytes for export */
    private originalBuffer;
    /** Files added after loadPptx (not in original ZIP) */
    private addedFiles;
    /** Files removed after loadPptx */
    private removedFiles;
    /** Binary files added/replaced after loadPptx (e.g. images) */
    private addedBinaryFiles;
    /** Canvas for text measurement (lazily created) */
    private canvas;
    private ctx;
    /** Custom text measurement function */
    private measureTextFn;
    /** Font fallback lookup map (source → comma-separated fallbacks) */
    private fontFallbackCache;
    /** Internal logger */
    private log;
    /** Past document states (top = most recent state before the current one). */
    private undoStack;
    /** Future document states for redo. */
    private redoStack;
    /** Nesting depth of beginBatch()/endBatch(). */
    private batchDepth;
    /** Whether the current batch has already recorded its pre-edit snapshot. */
    private batchRecorded;
    /** Max retained undo steps. */
    private maxHistory;
    /** Source for date-placeholder auto-content (see PptxRendererOptions.currentDate). */
    private currentDateOption?;
    constructor(options?: PptxRendererOptions);
    /** Get typed Wasm exports. */
    private get exports();
    /**
     * Initialize the renderer by loading the Wasm module.
     *
     * When called without arguments, the bundled Wasm binary is loaded
     * automatically via `import.meta.url` resolution. This works with
     * Vite, webpack, Rollup, and CDN imports (unpkg, jsdelivr).
     *
     * In Node.js, pass an ArrayBuffer (e.g. from `fs.readFileSync(path).buffer`)
     * or a file:// URL / http(s):// URL string.
     *
     * @param wasmSource - Optional URL string, file path (Node.js), or ArrayBuffer of .wasm bytes.
     *                     If omitted, the bundled Wasm is used.
     */
    init(wasmSource?: string | ArrayBuffer | Uint8Array): Promise<void>;
    /**
     * Load a PPTX file from an ArrayBuffer.
     * @returns Object with slideCount
     */
    loadPptx(arrayBuffer: ArrayBuffer): Promise<{
        slideCount: number;
    }>;
    /** Number of slides in the loaded presentation. */
    getSlideCount(): number;
    /** Check if a slide is hidden (0-indexed). */
    isSlideHidden(slideIdx: number): boolean;
    /** Get the raw XML of a slide (0-indexed). For debugging. */
    getSlideXmlRaw(slideIdx: number): string;
    /** Get all entry paths in the PPTX archive. For debugging. */
    getEntryList(): string[];
    /**
     * Render a slide as an SVG string (0-indexed).
     * @returns SVG markup, or a string starting with "ERROR:" on failure
     */
    renderSlideSvg(slideIdx: number): string;
    /**
     * Update a slide's internal data from an edited SVG string.
     * Parses the SVG's data-ooxml-* attributes back into SlideData.
     * @returns "OK" on success, "ERROR:..." on failure
     */
    updateSlideFromSvg(slideIdx: number, svgString: string): string;
    /**
     * Get the OOXML slide XML for a slide (0-indexed).
     * Returns modified XML if the slide was updated, otherwise original.
     */
    getSlideOoxml(slideIdx: number): string;
    /**
     * Export the (possibly modified) presentation as a PPTX ArrayBuffer.
     * Replaces modified slide XML entries in the original ZIP and rebuilds it.
     */
    exportPptx(): Promise<ArrayBuffer>;
    /**
     * Start a batch: all mutations until the matching {@link endBatch} collapse
     * into a single undo step. Calls may be nested; only the outermost pair has an
     * effect. Use this to make a compound action (e.g. paste = add shape + set
     * text + set fill) a single Ctrl+Z.
     */
    beginBatch(): void;
    /** End a batch started with {@link beginBatch}. */
    endBatch(): void;
    /** Whether there is at least one step that can be undone. */
    canUndo(): boolean;
    /** Whether there is at least one step that can be redone. */
    canRedo(): boolean;
    /** Discard all undo/redo history (e.g. after loading a new file). */
    clearHistory(): void;
    /**
     * Undo the most recent edit (or batch).
     * @returns JSON-encoded {@link HistoryResult} on success, or
     *          `"ERROR:nothing to undo"` if the history is empty.
     */
    undo(): string;
    /**
     * Redo the most recently undone edit (or batch).
     * @returns JSON-encoded {@link HistoryResult} on success, or
     *          `"ERROR:nothing to redo"` if there is nothing to redo.
     */
    redo(): string;
    /**
     * Record the pre-edit document state before a mutating operation. Called at
     * the top of every mutating public method. Within a batch, only the first
     * call records a snapshot. Any new edit clears the redo stack.
     */
    private checkpoint;
    /**
     * Commit a previously captured pre-edit snapshot to the undo stack, respecting
     * batch semantics. Lets callers capture the snapshot *before* a fallible op and
     * only commit it once the op is known to have succeeded (so a failed/no-op edit
     * leaves no phantom undo step). Returns true if a snapshot was recorded.
     */
    private commitCheckpoint;
    /**
     * Run a mutating `op` that returns `"OK..."`/SVG on success or `"ERROR:..."` on
     * failure, recording a history checkpoint **only when it succeeds** (so a failed
     * or no-op edit leaves no phantom undo step). The pre-edit snapshot is captured
     * before `op` runs. Used for fallible ops whose validation happens in Wasm.
     */
    private runGuarded;
    /** Capture a shallow snapshot of all state diverging from the original ZIP. */
    private captureSnapshot;
    /** Restore a previously captured snapshot, rebuilding Wasm state. */
    private restoreSnapshot;
    /** Compute which slides differ between two snapshots, for re-render hints. */
    private diffSnapshots;
    /**
     * Get speaker notes text for a slide (0-indexed).
     * @returns Array of paragraph strings, or empty array if no notes exist.
     */
    getSlideNotes(slideIdx: number): string[];
    /**
     * Get comments for a slide (0-indexed).
     * @returns Array of comment objects, or empty array if no comments exist.
     */
    getSlideComments(slideIdx: number): SlideComment[];
    /**
     * Get comment authors defined in the presentation.
     * @returns Array of author objects, or empty array if none exist.
     */
    getCommentAuthors(): CommentAuthor[];
    /**
     * Render a single shape as SVG (0-indexed slide and shape).
     * Returns SVG fragment (`<defs>...` + `<g>...</g>`), or "ERROR:..." on failure.
     */
    renderShapeSvg(slideIdx: number, shapeIdx: number): string;
    /**
     * Update a shape's transform (position, size, rotation) and return re-rendered SVG.
     * All values are in EMU. Marks the slide as modified.
     */
    updateShapeTransform(slideIdx: number, shapeIdx: number, x: number, y: number, cx: number, cy: number, rot: number): string;
    /**
     * Update several shapes' transforms atomically as a single undo step (EMU; rot
     * in 1/60000 deg). Every `shapeIdx` is validated before any change is applied,
     * so an invalid index leaves the slide untouched (no partial application). Use
     * for multi-select move/align. Re-render the slide afterwards with
     * `renderSlideSvg(slideIdx)`.
     * @returns `"OK:<count>"` on success, or `"ERROR:..."` on failure.
     */
    updateShapesTransform(slideIdx: number, items: Array<{
        shapeIdx: number;
        x: number;
        y: number;
        cx: number;
        cy: number;
        rot: number;
    }>): string;
    /**
     * Update a text run's content and return the shape's re-rendered SVG.
     * Marks the slide as modified.
     */
    updateShapeText(slideIdx: number, shapeIdx: number, paraIdx: number, runIdx: number, text: string): string;
    /**
     * Update a shape's solid fill color (RGB 0-255) and return re-rendered SVG.
     * Marks the slide as modified.
     */
    updateShapeFill(slideIdx: number, shapeIdx: number, r: number, g: number, b: number): string;
    /**
     * Delete a shape from a slide.
     * @returns "OK" on success, "ERROR:..." on failure.
     */
    deleteShape(slideIdx: number, shapeIdx: number): string;
    /**
     * Add a basic AutoShape to a slide.
     * @param geomType - Preset geometry: "rect", "ellipse", "roundRect", "line", etc.
     * @param x, y, cx, cy - Position and size in EMU.
     * @param fillR, fillG, fillB - Fill color (0-255). Pass -1 for no fill.
     * @returns "OK:<shapeIndex>" on success, "ERROR:..." on failure.
     */
    addShape(slideIdx: number, geomType: string, x: number, y: number, cx: number, cy: number, fillR?: number, fillG?: number, fillB?: number): string;
    /**
     * Add a text paragraph to a shape. Creates a single run with the given text.
     * @param fontSize - Font size in hundredths of a point (e.g. 1800 = 18pt). 0 = inherit.
     * @param colorR, colorG, colorB - Text color (0-255). Pass -1 for default/inherit.
     * @returns "OK:<paraIndex>" on success, "ERROR:..." on failure.
     */
    addShapeText(slideIdx: number, shapeIdx: number, text: string, fontSize?: number, colorR?: number, colorG?: number, colorB?: number): string;
    /**
     * Duplicate a shape, offset by (dxEmu, dyEmu) from the original.
     * @returns "OK:<shapeIndex>" on success, "ERROR:..." on failure.
     */
    duplicateShape(slideIdx: number, shapeIdx: number, dxEmu?: number, dyEmu?: number): string;
    /**
     * Update a shape's fill to a linear gradient. Returns re-rendered SVG.
     * @param angle - Gradient angle in 60000ths of a degree (e.g. 5400000 = 90deg).
     * @param stops - Array of { pos, r, g, b } where pos is 0-100000.
     */
    updateShapeGradientFill(slideIdx: number, shapeIdx: number, angle: number, stops: Array<{
        pos: number;
        r: number;
        g: number;
        b: number;
    }>): string;
    /**
     * Update a shape's stroke (outline). Returns re-rendered SVG.
     * @param r, g, b - Stroke color (0-255). Pass -1 to remove stroke.
     * @param widthEmu - Stroke width in EMU (default 12700 = 1pt).
     * @param dash - Dash preset: "dash", "dot", "dashDot", "lgDash", etc. "" = solid.
     */
    updateShapeStroke(slideIdx: number, shapeIdx: number, r: number, g: number, b: number, widthEmu?: number, dash?: string): string;
    /**
     * Add a new paragraph to a shape with a single text run.
     * @param align - "l" (left), "ctr" (center), "r" (right), "just" (justify), "" (inherit).
     * @returns "OK:<paraIndex>" on success, "ERROR:..." on failure.
     */
    addParagraph(slideIdx: number, shapeIdx: number, text: string, align?: string): string;
    /**
     * Delete a paragraph from a shape.
     * @returns "OK" on success, "ERROR:..." on failure.
     */
    deleteParagraph(slideIdx: number, shapeIdx: number, paraIdx: number): string;
    /**
     * Add a new text run to a paragraph.
     * @returns "OK:<runIndex>" on success, "ERROR:..." on failure.
     */
    addRun(slideIdx: number, shapeIdx: number, paraIdx: number, text: string): string;
    /**
     * Delete a text run from a paragraph.
     * @returns "OK" on success, "ERROR:..." on failure.
     */
    deleteRun(slideIdx: number, shapeIdx: number, paraIdx: number, runIdx: number): string;
    /**
     * Update a text run's bold/italic style. Returns re-rendered shape SVG.
     * @param bold - 1 = set bold, 0 = unset bold, -1 = no change.
     * @param italic - 1 = set italic, 0 = unset italic, -1 = no change.
     */
    updateTextRunStyle(slideIdx: number, shapeIdx: number, paraIdx: number, runIdx: number, bold?: number, italic?: number): string;
    /**
     * Update a text run's font size. Returns re-rendered shape SVG.
     * @param fontSize - In hundredths of a point (e.g. 1800 = 18pt). 0 = inherit.
     */
    updateTextRunFontSize(slideIdx: number, shapeIdx: number, paraIdx: number, runIdx: number, fontSize: number): string;
    /**
     * Update a text run's color (RGB 0-255). Returns re-rendered shape SVG.
     * Pass r = -1 to clear (inherit from theme/master).
     */
    updateTextRunColor(slideIdx: number, shapeIdx: number, paraIdx: number, runIdx: number, r: number, g: number, b: number): string;
    /**
     * Update a text run's font family. Returns re-rendered shape SVG.
     * @param fontFace - Latin font name. Empty string = no change.
     * @param eaFont - East Asian font name. Empty string = no change.
     * @param csFont - Complex Script font name. Empty string = no change.
     */
    updateTextRunFont(slideIdx: number, shapeIdx: number, paraIdx: number, runIdx: number, fontFace?: string, eaFont?: string, csFont?: string): string;
    /**
     * Update a paragraph's alignment. Returns re-rendered shape SVG.
     * @param align - "l" (left), "ctr" (center), "r" (right), "just" (justify), "" (inherit).
     */
    updateParagraphAlign(slideIdx: number, shapeIdx: number, paraIdx: number, align: string): string;
    /**
     * Update a text run's decoration (underline, strikethrough, baseline shift).
     * Returns re-rendered shape SVG.
     * @param underline - "sng" (single), "dbl" (double), "" (no change), "none" (remove).
     * @param strike - "sngStrike", "dblStrike", "" (no change), "none" (remove).
     * @param baseline - 30000 = superscript, -25000 = subscript, 0 = normal, -1 = no change.
     */
    updateTextRunDecoration(slideIdx: number, shapeIdx: number, paraIdx: number, runIdx: number, underline?: string, strike?: string, baseline?: number): string;
    /**
     * Get the text geometry of a shape's text body for caret / selection rendering.
     * @returns JSON-encoded {@link TextLayout} string (coordinates in EMU), or
     *          `"ERROR:..."` on failure.
     *
     * Scope: horizontal LTR text (left/center/right/justify). Vertical text, warp,
     * OMML math, and multi-column bodies return only the bounding box with no lines.
     * Line and run counts match the rendered SVG (shared wrapping/autofit).
     */
    getTextLayout(slideIdx: number, shapeIdx: number): string;
    /**
     * Hit-test a point (EMU) against a shape's text to find the caret insertion point.
     * @returns JSON-encoded {@link TextHit} string, or `"ERROR:..."` on failure.
     *          `charOffset` is within the run; `paraOffset` is within the paragraph
     *          (pass `paraOffset` values to {@link replaceTextRange}).
     */
    hitTestText(slideIdx: number, shapeIdx: number, xEmu: number, yEmu: number): string;
    /**
     * Replace a text range with `newText`, preserving the formatting of the runs at
     * the range boundaries (splitting/merging runs as needed). Returns re-rendered
     * shape SVG, or `"ERROR:..."` on failure.
     *
     * `startChar` / `endChar` are paragraph-level character offsets (use `paraOffset`
     * from {@link hitTestText}). A collapsed range (start == end) inserts; an empty
     * `newText` deletes. `\n` in `newText` splits into multiple paragraphs.
     */
    replaceTextRange(slideIdx: number, shapeIdx: number, startPara: number, startChar: number, endPara: number, endChar: number, newText: string): string;
    /**
     * Move a shape to the front (top of the z-order).
     * @returns `"OK:<newShapeIdx>"` (the shape's index changes when reordered, so the
     *          caller can re-select it), or `"ERROR:..."` on failure.
     */
    bringToFront(slideIdx: number, shapeIdx: number): string;
    /**
     * Move a shape to the back (bottom of the z-order).
     * @returns `"OK:<newShapeIdx>"`, or `"ERROR:..."` on failure.
     */
    sendToBack(slideIdx: number, shapeIdx: number): string;
    /**
     * Move a shape one step toward the front (no-op if already front-most).
     * @returns `"OK:<newShapeIdx>"`, or `"ERROR:..."` on failure.
     */
    bringForward(slideIdx: number, shapeIdx: number): string;
    /**
     * Move a shape one step toward the back (no-op if already back-most).
     * @returns `"OK:<newShapeIdx>"`, or `"ERROR:..."` on failure.
     */
    sendBackward(slideIdx: number, shapeIdx: number): string;
    /**
     * Extract a shape as a portable, self-contained spec for copy/paste — including
     * any referenced images inline (base64), so it survives a clipboard round-trip
     * and can be pasted onto another slide (or another presentation).
     * @returns JSON-encoded {@link ShapeSpec} string, or `"ERROR:..."` on failure
     *          (e.g. charts, which serialize out-of-band, are not copyable in v1).
     */
    getShapeSpec(slideIdx: number, shapeIdx: number): string;
    /**
     * Paste a {@link ShapeSpec} (from {@link getShapeSpec}) onto a slide, offset by
     * (dxEmu, dyEmu). Inlined media is re-added to the package and the shape's image
     * relationships are re-linked to fresh rIds on the target slide. Undoable.
     * @returns `"OK:<shapeIdx>"` on success, or `"ERROR:..."` on failure.
     */
    insertShapeSpec(slideIdx: number, spec: string, dxEmu?: number, dyEmu?: number): string;
    /**
     * Set a table cell's text (plain text, replacing the cell's contents). The new
     * text inherits the cell's existing first-run formatting when present.
     * Returns re-rendered shape SVG, or `"ERROR:..."` (e.g. not a table).
     */
    updateTableCellText(slideIdx: number, shapeIdx: number, row: number, col: number, text: string): string;
    /**
     * Insert an empty row. `afterRow = -1` inserts at the top; otherwise after the
     * given row. Returns `"OK:<newRowIdx>"`, or `"ERROR:..."`.
     * Note: tables with merged cells are not span-adjusted (v1 limitation).
     */
    addTableRow(slideIdx: number, shapeIdx: number, afterRow?: number): string;
    /** Delete a table row (at least one must remain). Returns `"OK"` or `"ERROR:..."`. */
    deleteTableRow(slideIdx: number, shapeIdx: number, row: number): string;
    /**
     * Insert an empty column. `afterCol = -1` inserts at the left; otherwise after
     * the given column. `widthEmu = 0` copies a neighbour's width. Returns
     * `"OK:<newColIdx>"`, or `"ERROR:..."`. Merged cells are not span-adjusted (v1).
     */
    addTableColumn(slideIdx: number, shapeIdx: number, afterCol?: number, widthEmu?: number): string;
    /** Delete a table column (at least one must remain). Returns `"OK"` or `"ERROR:..."`. */
    deleteTableColumn(slideIdx: number, shapeIdx: number, col: number): string;
    /**
     * Add a blank slide at the specified position (0-indexed).
     * If `afterIdx` is omitted, the slide is appended at the end.
     * If `sourceSlideIdx` is provided, the new slide copies that slide's layout.
     *
     * @param afterIdx - Insert after this slide index (0-indexed). Use -1 to insert at the beginning.
     * @param sourceSlideIdx - Copy layout from this slide (0-indexed). Defaults to last slide.
     * @returns Object with the new slide count and the index of the inserted slide.
     */
    addSlide(afterIdx?: number, sourceSlideIdx?: number): Promise<{
        slideCount: number;
        insertedIdx: number;
    }>;
    /**
     * Delete a slide at the specified index (0-indexed).
     * At least one slide must remain.
     *
     * @param slideIdx - The 0-indexed slide to delete.
     * @returns Object with the new slide count.
     */
    deleteSlide(slideIdx: number): Promise<{
        slideCount: number;
    }>;
    /**
     * Reorder slides according to the given index mapping.
     *
     * @param newOrder - Array where newOrder[i] is the old index of the slide that should appear at position i.
     *                   Must be a permutation of [0, 1, ..., slideCount-1].
     * @returns Object with the slide count (unchanged).
     */
    reorderSlides(newOrder: number[]): Promise<{
        slideCount: number;
    }>;
    /** Rewrite slide files in the files map with correct 1..N numbering. */
    private rewriteSlideFiles;
    /** Extract a relationship target from .rels XML by type suffix. */
    private extractRelTarget;
    /** Extract slide size from presentation.xml. */
    private extractSlideSize;
    /** Create minimal blank slide XML. */
    private createBlankSlideXml;
    /** Find the next available sldId in presentation.xml. */
    private findNextSlideId;
    /** Find the next available rId in a .rels XML string. */
    private nextRid;
    /** Update presentation.xml and .rels for slide addition. */
    private updatePresentationXmlForAdd;
    /** Update presentation.xml and .rels for slide deletion. */
    private updatePresentationXmlForDelete;
    /** Update presentation.xml sldId order for reorder. */
    private updatePresentationXmlForReorder;
    /** Parse all <p:sldId .../> entries from presentation.xml as raw strings. */
    private parseSldIdEntries;
    /** Parse slide relationships: rId → target path. */
    private parseSlideRelationships;
    /** Ensure [Content_Types].xml has an Override for the given slide number. */
    private ensureContentTypeForSlide;
    /**
     * Add an image to a slide as a Picture shape.
     * @param slideIdx - Slide index (0-based).
     * @param imageData - Raw image bytes (PNG, JPEG, GIF, etc.).
     * @param mimeType - MIME type (e.g. "image/png", "image/jpeg").
     * @param x, y, cx, cy - Position and size in EMU.
     * @returns "OK:<shapeIndex>" on success, "ERROR:..." on failure.
     */
    addImage(slideIdx: number, imageData: Uint8Array, mimeType: string, x: number, y: number, cx: number, cy: number): string;
    /**
     * Replace the image data of an existing Picture shape.
     * @param slideIdx - Slide index (0-based).
     * @param shapeIdx - Shape index (composite index for groups).
     * @param imageData - New image bytes.
     * @param mimeType - MIME type of the new image.
     * @returns "OK" on success, "ERROR:..." on failure.
     */
    replaceImage(slideIdx: number, shapeIdx: number, imageData: Uint8Array, mimeType: string): string;
    /**
     * Delete a Picture shape and mark its media file for removal.
     * @param slideIdx - Slide index (0-based).
     * @param shapeIdx - Shape index.
     * @returns "OK" on success, "ERROR:..." on failure.
     */
    deleteImage(slideIdx: number, shapeIdx: number): string;
    /** Resolve a relationship ID to its Target attribute in a .rels XML string. */
    private resolveRidTarget;
    /** Generate the next available media file path. */
    private nextMediaPath;
    /** Ensure [Content_Types].xml has a Default entry for the given extension. */
    private ensureContentTypeForExtension;
    /** Check if a media file is referenced by any slide other than the given one. */
    private isMediaReferencedElsewhere;
    /** Update a file in both the live files map and the export tracking map. */
    private persistFile;
    /** Re-initialize the Wasm engine after structural changes to the files map. */
    private reinitializeWasm;
    /** Build the Wasm import object that satisfies MoonBit's FFI declarations. */
    private buildImportObject;
    /**
     * Resolve the date string for auto-updating date placeholders. Honors the
     * `currentDate` option (Date | string | factory); defaults to the locale
     * short date. Returns "" only if a custom source explicitly yields it.
     */
    private currentDate;
    /** Convert an EMF/WMF file to an SVG data URI. Returns "" if conversion fails. */
    private convertEmf;
    /** Quote a font name for use in CSS font shorthand (names with spaces need quotes). */
    private static quoteFontName;
    /** Measure the rendered pixel width of text. */
    private measureText;
    /**
     * Resolve a relationship target path for a slide.
     * @param slideIdx - 0-indexed slide index
     * @param relType - last segment of the relationship type (e.g. 'notesSlide', 'comments')
     */
    private resolveRelTarget;
    /** Resolve a relative path like "../notesSlides/notesSlide1.xml" from a base dir. */
    private resolveRelPath;
    /**
     * Decode XML entity references in a raw inner-text string. Returns plain
     * text suitable for `.textContent`. Callers must NOT pass the result to
     * `.innerHTML` — use `.textContent` to avoid HTML re-interpretation.
     */
    private decodeXmlEntities;
    /** Extract text paragraphs from a notesSlide XML (body placeholder). */
    private extractNotesText;
    /** Parse comments XML into SlideComment array. */
    private parseComments;
    /** Parse commentAuthors XML into CommentAuthor array. */
    private parseCommentAuthors;
}
//# sourceMappingURL=pptx-renderer.d.ts.map