web-doc 0.6.2 → 0.8.0

package/dist/edit/pptx/model.js

@@ -0,0 +1,170 @@
+import { ViewerError } from "../../errors.js";
+/*
+ * The deck index: which parts are the presentation, its slides in order,
+ * their layouts, the masters and their themes. Built from the package at a
+ * revision and rebuilt when the revision changes; everything else about a
+ * slide is read on demand.
+ */
+export const PRESENTATION_NS = "http://schemas.openxmlformats.org/presentationml/2006/main";
+const OFFICE_RELATIONSHIPS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/";
+export const RELATIONSHIP_TYPES = {
+    officeDocument: `${OFFICE_RELATIONSHIPS}officeDocument`,
+    slide: `${OFFICE_RELATIONSHIPS}slide`,
+    slideLayout: `${OFFICE_RELATIONSHIPS}slideLayout`,
+    slideMaster: `${OFFICE_RELATIONSHIPS}slideMaster`,
+    notesSlide: `${OFFICE_RELATIONSHIPS}notesSlide`,
+    theme: `${OFFICE_RELATIONSHIPS}theme`,
+    image: `${OFFICE_RELATIONSHIPS}image`,
+};
+/** The number in a part name like `/ppt/slides/slide12.xml`. */
+export function partNumber(part) {
+    const match = /(\d+)\.xml$/i.exec(part);
+    return match ? Number(match[1]) : 0;
+}
+export class DeckModel {
+    revision;
+    presentationPart;
+    presentation;
+    slideSize;
+    slides;
+    layouts;
+    masters;
+    #pkg;
+    #themeFonts = new Map();
+    constructor(pkg, revision, presentationPart, presentation, 
+    /** EMU. */
+    slideSize, slides, layouts, masters) {
+        this.revision = revision;
+        this.presentationPart = presentationPart;
+        this.presentation = presentation;
+        this.slideSize = slideSize;
+        this.slides = slides;
+        this.layouts = layouts;
+        this.masters = masters;
+        this.#pkg = pkg;
+    }
+    static async load(pkg, signal) {
+        const root = await pkg.relationships("/", signal);
+        const main = root.byType(RELATIONSHIP_TYPES.officeDocument)[0]?.targetPart;
+        if (!main)
+            throw new ViewerError("invalid-file", "The package has no presentation part");
+        const presentation = await pkg.xml(main, signal);
+        const size = presentation.find("sldSz");
+        const slideSize = {
+            cx: Number(size ? presentation.attribute(size, "cx") : NaN) || 9144000,
+            cy: Number(size ? presentation.attribute(size, "cy") : NaN) || 6858000,
+        };
+        const rels = await pkg.relationships(main, signal);
+        const masters = [];
+        const layouts = [];
+        const layoutByPart = new Map();
+        for (const masterId of presentation.findAll("sldMasterId")) {
+            const rId = presentation.attribute(masterId, "r:id");
+            const part = rId ? rels.byId(rId)?.targetPart : undefined;
+            if (!part || !pkg.has(part))
+                continue;
+            const masterRels = await pkg.relationships(part, signal);
+            const theme = masterRels.byType(RELATIONSHIP_TYPES.theme)[0]?.targetPart;
+            const layoutParts = masterRels
+                .byType(RELATIONSHIP_TYPES.slideLayout)
+                .map((relationship) => relationship.targetPart)
+                .filter((name) => !!name && pkg.has(name))
+                .sort((a, b) => partNumber(a) - partNumber(b));
+            const master = {
+                id: `master${partNumber(part)}`,
+                part,
+                ...(theme ? { theme } : {}),
+                layouts: layoutParts,
+            };
+            masters.push(master);
+            for (const layoutPart of layoutParts) {
+                if (layoutByPart.has(layoutPart))
+                    continue;
+                const xml = await pkg.xml(layoutPart, signal);
+                const cSld = xml.find("cSld");
+                const type = xml.attribute(xml.root, "type");
+                const layout = {
+                    id: `layout${partNumber(layoutPart)}`,
+                    part: layoutPart,
+                    name: (cSld ? xml.attribute(cSld, "name") : undefined) ?? "",
+                    ...(type ? { type } : {}),
+                    master,
+                };
+                layouts.push(layout);
+                layoutByPart.set(layoutPart, layout);
+            }
+        }
+        const slides = [];
+        for (const node of presentation.findAll("sldId")) {
+            // Section lists (p14:sldId) name slides too; only p:sldIdLst lists them.
+            if (node.namespace !== PRESENTATION_NS)
+                continue;
+            const rId = presentation.attribute(node, "r:id");
+            const id = presentation.attribute(node, "id");
+            const part = rId ? rels.byId(rId)?.targetPart : undefined;
+            if (!rId || !id || !part || !pkg.has(part))
+                throw new ViewerError("invalid-file", `Slide ${id ?? "?"} of the presentation has no part`);
+            const slideRels = await pkg.relationships(part, signal);
+            const layoutPart = slideRels.byType(RELATIONSHIP_TYPES.slideLayout)[0]
+                ?.targetPart;
+            const layout = layoutPart ? layoutByPart.get(layoutPart) : undefined;
+            const number = partNumber(part);
+            if (slides.some((slide) => slide.number === number))
+                throw new ViewerError("invalid-file", `Two slide parts share the number ${number}`, { details: { part } });
+            slides.push({
+                key: `sld${number}`,
+                number,
+                part,
+                id,
+                rId,
+                node,
+                ...(layout ? { layout } : {}),
+            });
+        }
+        return new DeckModel(pkg, pkg.revision, main, presentation, slideSize, slides, layouts, masters);
+    }
+    get pageCount() {
+        return this.slides.length;
+    }
+    slideAt(pageIndex) {
+        const slide = this.slides[pageIndex];
+        if (!Number.isInteger(pageIndex) || !slide)
+            throw new ViewerError("invalid-operation", `Slide index ${pageIndex} is out of range`, { details: { pageIndex, pageCount: this.slides.length } });
+        return slide;
+    }
+    slideByKey(key) {
+        return this.slides.find((slide) => slide.key === key);
+    }
+    layoutById(id) {
+        return this.layouts.find((layout) => layout.id === id);
+    }
+    /** Whether a slide is hidden (`p:sld/@show="0"`). */
+    async hidden(slide, signal) {
+        const xml = await this.#pkg.xml(slide.part, signal);
+        return xml.attribute(xml.root, "show") === "0";
+    }
+    /** The major and minor Latin faces of a master's theme. */
+    themeFonts(master) {
+        const theme = master?.theme;
+        if (!theme || !this.#pkg.has(theme))
+            return Promise.resolve({ major: "Calibri Light", minor: "Calibri" });
+        let fonts = this.#themeFonts.get(theme);
+        if (!fonts) {
+            fonts = this.#pkg.xml(theme).then((xml) => {
+                const face = (scheme) => {
+                    const node = xml.find(scheme);
+                    const latin = node
+                        ? node.children.find((child) => child.local === "latin")
+                        : undefined;
+                    return latin ? xml.attribute(latin, "typeface") : undefined;
+                };
+                return {
+                    major: face("majorFont") || "Calibri Light",
+                    minor: face("minorFont") || "Calibri",
+                };
+            });
+            this.#themeFonts.set(theme, fonts);
+        }
+        return fonts;
+    }
+}

package/dist/edit/pptx/operations.d.ts

@@ -0,0 +1,50 @@
+import type { ResourceLimits, ViewerWarning } from "../../contracts.js";
+import type { AssetSource } from "../assets.js";
+import type { OoxmlPackage } from "../ooxml/package.js";
+import type { CommittedChange } from "../ooxml/transaction.js";
+import type { OperationIssue } from "../types.js";
+import type { ShapeRecord, SlideElements } from "./elements.js";
+import type { DeckModel } from "./model.js";
+import type { PptxOperation } from "./types.js";
+export interface PptxOperationContext {
+    readonly pkg: OoxmlPackage;
+    readonly model: DeckModel;
+    readonly limits: ResourceLimits;
+    /** Bytes behind `asset:` references. */
+    readonly assets: AssetSource;
+    /** Slides after the operations before this one in the batch; the model's count when applying. */
+    readonly pageCount: number;
+    /** The batch's state id, for ids an operation derives. */
+    readonly stateId: number;
+    readonly operationIndex: number;
+    /** Every element of a slide, read at the current revision. */
+    elements(pageIndex: number): Promise<SlideElements>;
+    /** The element an id names, at the current revision. */
+    locate(id: string): Promise<ShapeRecord | undefined>;
+    /**
+     * A `p:cNvPr` id for an element created on a slide: above every id the
+     * slide holds and above every id the session already issued there, so
+     * an id is never reused after a deletion.
+     */
+    allocateShapeId(elements: SlideElements): number;
+}
+export interface PptxOperationResult {
+    readonly createdIds: readonly string[];
+    readonly removedIds?: readonly string[];
+    readonly changedPages: readonly number[];
+    readonly warnings: readonly ViewerWarning[];
+    /** Parts the operation's transaction changed, added and removed; absent means "everything may have". */
+    readonly parts?: {
+        readonly changed: readonly string[];
+        readonly added: readonly string[];
+        readonly removed: readonly string[];
+    };
+}
+export type Issue = (path: string, code: string, message: string) => void;
+export interface PptxOperationHandler<T extends PptxOperation = PptxOperation> {
+    validate(operation: T, context: PptxOperationContext, issue: Issue): Promise<void>;
+    apply(operation: T, context: PptxOperationContext): Promise<PptxOperationResult>;
+}
+export declare function issueCollector(operationIndex: number, issues: OperationIssue[]): Issue;
+/** The parts a transaction touched, in the shape an operation result carries. */
+export declare function committedParts(change: CommittedChange): NonNullable<PptxOperationResult["parts"]>;

package/dist/edit/pptx/operations.js

@@ -0,0 +1,11 @@
+export function issueCollector(operationIndex, issues) {
+    return (path, code, message) => issues.push({ operationIndex, path, code, message });
+}
+/** The parts a transaction touched, in the shape an operation result carries. */
+export function committedParts(change) {
+    return {
+        changed: change.changedParts,
+        added: change.addedParts,
+        removed: change.removedParts,
+    };
+}

package/dist/edit/pptx/provider.d.ts

@@ -0,0 +1,17 @@
+import type { EditEngineContext } from "../engine.js";
+import { type OoxmlEditProviderOptions } from "../ooxml/worker.js";
+import { WorkerEngineClient } from "../worker-engine.js";
+import type { PptxEngineReads } from "./engine.js";
+import type { PptxLayoutInfo, PptxSlideInfo } from "./types.js";
+export type PptxEditProviderOptions = OoxmlEditProviderOptions;
+/**
+ * Starts the OOXML edit worker for `original` as a PPTX engine. Loaded
+ * lazily by the Office adapter's provider on the first `edit()`.
+ */
+export declare function loadPptxEditEngine(original: Uint8Array, context: EditEngineContext, options?: PptxEditProviderOptions): Promise<PptxEditEngineClient>;
+export declare class PptxEditEngineClient extends WorkerEngineClient implements PptxEngineReads {
+    readonly schemas: import("../types.js").OperationSchemaSet;
+    start(original: Uint8Array): Promise<void>;
+    slides(signal: AbortSignal): Promise<readonly PptxSlideInfo[]>;
+    layouts(signal: AbortSignal): Promise<readonly PptxLayoutInfo[]>;
+}

package/dist/edit/pptx/provider.js

@@ -0,0 +1,40 @@
+import { WorkerRpcClient } from "../../worker-client.js";
+import { createOoxmlEditWorker, } from "../ooxml/worker.js";
+import { WorkerEngineClient } from "../worker-engine.js";
+import { pptxOperationSchemas } from "./schemas.js";
+/**
+ * Starts the OOXML edit worker for `original` as a PPTX engine. Loaded
+ * lazily by the Office adapter's provider on the first `edit()`.
+ */
+export async function loadPptxEditEngine(original, context, options = {}) {
+    const worker = createOoxmlEditWorker(options, context);
+    const rpc = new WorkerRpcClient(worker);
+    const engine = new PptxEditEngineClient(rpc, context);
+    try {
+        await engine.start(original);
+        return engine;
+    }
+    catch (error) {
+        rpc.destroy();
+        throw error;
+    }
+}
+export class PptxEditEngineClient extends WorkerEngineClient {
+    schemas = pptxOperationSchemas;
+    async start(original) {
+        const data = original.slice().buffer;
+        const open = {
+            data,
+            limits: this.context.limits,
+            format: "pptx",
+            ...(this.context.fileName ? { fileName: this.context.fileName } : {}),
+        };
+        await this.request("edit-open", open, this.context.signal, [data]);
+    }
+    slides(signal) {
+        return this.request("edit-pptx-slides", undefined, signal);
+    }
+    layouts(signal) {
+        return this.request("edit-pptx-layouts", undefined, signal);
+    }
+}

package/dist/edit/pptx/schemas.d.ts

@@ -0,0 +1,6 @@
+import type { OperationSchemaSet } from "../types.js";
+/** Operations with an engine handler; grows as the tasks land. */
+export declare const IMPLEMENTED_OPERATIONS: readonly string[];
+export declare const pptxOperationSchemas: OperationSchemaSet;
+/** Every schema, implemented or not, for the conformance test. */
+export declare const pptxOperationSchemaDrafts: Readonly<Record<string, Readonly<Record<string, unknown>>>>;

package/dist/edit/pptx/schemas.js

@@ -0,0 +1,220 @@
+/*
+ * JSON Schemas of the PPTX operations, shared by the worker (engine
+ * validation), the main thread (shape checks) and clients (`session.schemas`).
+ * Only keywords the in-repo validator implements may appear here. The
+ * exported set lists the operations that have an engine handler.
+ */
+const definitions = {
+    // DrawingML coordinates are bounded (ST_Coordinate: ±27,273,042,316,900 EMU).
+    coordinate: {
+        type: "number",
+        minimum: -2_800_000_000,
+        maximum: 2_800_000_000,
+    },
+    extent: { type: "number", exclusiveMinimum: 0, maximum: 2_800_000_000 },
+    rect: {
+        type: "object",
+        required: ["x", "y", "width", "height"],
+        additionalProperties: false,
+        properties: {
+            x: { $ref: "#/$defs/coordinate" },
+            y: { $ref: "#/$defs/coordinate" },
+            width: { $ref: "#/$defs/extent" },
+            height: { $ref: "#/$defs/extent" },
+        },
+    },
+    point: {
+        type: "object",
+        required: ["x", "y"],
+        additionalProperties: false,
+        properties: {
+            x: { $ref: "#/$defs/coordinate" },
+            y: { $ref: "#/$defs/coordinate" },
+        },
+    },
+    offset: {
+        type: "object",
+        required: ["dx", "dy"],
+        additionalProperties: false,
+        properties: {
+            dx: { $ref: "#/$defs/coordinate" },
+            dy: { $ref: "#/$defs/coordinate" },
+        },
+    },
+    target: { type: "string", minLength: 1, maxLength: 200 },
+    textPosition: {
+        type: "object",
+        required: ["elementId", "offset"],
+        additionalProperties: false,
+        properties: {
+            elementId: { $ref: "#/$defs/target" },
+            offset: { type: "integer", minimum: 0 },
+        },
+    },
+    textRange: {
+        type: "object",
+        required: ["start", "end"],
+        additionalProperties: false,
+        properties: {
+            start: { $ref: "#/$defs/textPosition" },
+            end: { $ref: "#/$defs/textPosition" },
+        },
+    },
+    text: { type: "string", maxLength: 100_000 },
+    rgb: { type: "string", pattern: "^#[0-9A-Fa-f]{6}$" },
+    themeColor: {
+        type: "object",
+        required: ["theme"],
+        additionalProperties: false,
+        properties: {
+            theme: { type: "string", minLength: 1, maxLength: 20 },
+            mods: { type: "object" },
+        },
+    },
+    color: { oneOf: [{ $ref: "#/$defs/rgb" }, { $ref: "#/$defs/themeColor" }] },
+    colorOrNone: {
+        oneOf: [
+            { $ref: "#/$defs/rgb" },
+            { $ref: "#/$defs/themeColor" },
+            { const: "none" },
+        ],
+    },
+    textStyle: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            fontFamily: { type: "string", minLength: 1, maxLength: 100 },
+            fontSize: { type: "number", minimum: 1, maximum: 400 },
+            bold: { type: "boolean" },
+            italic: { type: "boolean" },
+            underline: { type: "boolean" },
+            color: { $ref: "#/$defs/color" },
+            align: { enum: ["left", "center", "right", "justify"] },
+        },
+    },
+    line: {
+        type: "object",
+        required: ["color"],
+        additionalProperties: false,
+        properties: {
+            color: { $ref: "#/$defs/colorOrNone" },
+            width: { type: "number", minimum: 0, maximum: 100 },
+        },
+    },
+    tableStyle: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            firstRow: { type: "boolean" },
+            bandRow: { type: "boolean" },
+        },
+    },
+    tableRows: {
+        type: "array",
+        minItems: 1,
+        maxItems: 100,
+        items: {
+            type: "array",
+            minItems: 1,
+            maxItems: 20,
+            items: { type: "string", maxLength: 10_000 },
+        },
+    },
+    index: { type: "integer", minimum: 0, maximum: 100_000 },
+};
+function operation(name, properties, required) {
+    return {
+        type: "object",
+        required: ["op", ...required],
+        additionalProperties: false,
+        properties: { op: { const: name }, ...properties },
+        $defs: definitions,
+    };
+}
+const all = {
+    replaceText: operation("replaceText", {
+        target: { $ref: "#/$defs/target" },
+        text: { $ref: "#/$defs/text" },
+        range: { $ref: "#/$defs/textRange" },
+    }, ["target", "text"]),
+    setTextStyle: operation("setTextStyle", {
+        target: { $ref: "#/$defs/target" },
+        range: { $ref: "#/$defs/textRange" },
+        style: { $ref: "#/$defs/textStyle" },
+    }, ["target", "style"]),
+    setShapeStyle: operation("setShapeStyle", {
+        target: { $ref: "#/$defs/target" },
+        fill: { oneOf: [{ $ref: "#/$defs/colorOrNone" }, { type: "null" }] },
+        line: {
+            oneOf: [{ $ref: "#/$defs/line" }, { const: "none" }, { type: "null" }],
+        },
+    }, ["target"]),
+    moveElement: operation("moveElement", {
+        target: { $ref: "#/$defs/target" },
+        to: { $ref: "#/$defs/point" },
+        by: { $ref: "#/$defs/offset" },
+    }, ["target"]),
+    resizeElement: operation("resizeElement", { target: { $ref: "#/$defs/target" }, rect: { $ref: "#/$defs/rect" } }, ["target", "rect"]),
+    deleteElement: operation("deleteElement", { target: { $ref: "#/$defs/target" } }, ["target"]),
+    insertTextBox: operation("insertTextBox", {
+        pageIndex: { $ref: "#/$defs/index" },
+        rect: { $ref: "#/$defs/rect" },
+        text: { $ref: "#/$defs/text" },
+        style: { $ref: "#/$defs/textStyle" },
+    }, ["pageIndex", "rect", "text"]),
+    insertImage: operation("insertImage", {
+        pageIndex: { $ref: "#/$defs/index" },
+        rect: { $ref: "#/$defs/rect" },
+        data: { "x-binary": true, type: "string", contentEncoding: "base64" },
+        mimeType: { enum: ["image/png", "image/jpeg"] },
+    }, ["pageIndex", "rect", "data", "mimeType"]),
+    insertTable: operation("insertTable", {
+        pageIndex: { $ref: "#/$defs/index" },
+        rect: { $ref: "#/$defs/rect" },
+        rows: { $ref: "#/$defs/tableRows" },
+        columnWidths: {
+            type: "array",
+            minItems: 1,
+            maxItems: 20,
+            items: { type: "number", exclusiveMinimum: 0 },
+        },
+        style: { $ref: "#/$defs/tableStyle" },
+    }, ["pageIndex", "rect", "rows"]),
+    setTableCell: operation("setTableCell", {
+        target: { $ref: "#/$defs/target" },
+        row: { $ref: "#/$defs/index" },
+        column: { $ref: "#/$defs/index" },
+        text: { $ref: "#/$defs/text" },
+    }, ["target", "row", "column", "text"]),
+    insertSlide: operation("insertSlide", {
+        index: { $ref: "#/$defs/index" },
+        layout: { type: "string", minLength: 1, maxLength: 50 },
+    }, ["index"]),
+    duplicateSlide: operation("duplicateSlide", { pageIndex: { $ref: "#/$defs/index" }, index: { $ref: "#/$defs/index" } }, ["pageIndex"]),
+    deleteSlide: operation("deleteSlide", { pageIndex: { $ref: "#/$defs/index" } }, ["pageIndex"]),
+    moveSlide: operation("moveSlide", { from: { $ref: "#/$defs/index" }, to: { $ref: "#/$defs/index" } }, ["from", "to"]),
+};
+/** Operations with an engine handler; grows as the tasks land. */
+export const IMPLEMENTED_OPERATIONS = [
+    "replaceText",
+    "setTextStyle",
+    "setShapeStyle",
+    "moveElement",
+    "resizeElement",
+    "deleteElement",
+    "insertTextBox",
+    "insertImage",
+    "insertTable",
+    "setTableCell",
+    "insertSlide",
+    "duplicateSlide",
+    "deleteSlide",
+    "moveSlide",
+];
+export const pptxOperationSchemas = Object.freeze({
+    format: "pptx",
+    version: 1,
+    operations: Object.freeze(Object.fromEntries(IMPLEMENTED_OPERATIONS.map((name) => [name, all[name]]))),
+});
+/** Every schema, implemented or not, for the conformance test. */
+export const pptxOperationSchemaDrafts = all;

package/dist/edit/pptx/session.d.ts

@@ -0,0 +1,54 @@
+import type { DescribeOptions, DocumentDescription, EditCheckpoint, OutlineOptions, OutlineResult, TargetCandidate, TargetQuery, ToolCall, ToolCallOptions, ToolResult, ToolSet } from "../ai/types.js";
+import type { EditSessionCore } from "../engine.js";
+import type { ApplyOptions, AssetOptions, EditFindOptions, EditOperation, EditReceipt, EditState, ElementQuery, HistoryOptions, OperationSchemaSet, PagePoint, ReadItem, ReadOptions, ReadResult, SavedDocument, TextTarget } from "../types.js";
+import type { PptxDeleteElementOperation, PptxDeleteSlideOperation, PptxDuplicateSlideOperation, PptxEditSession, PptxElement, PptxFields, PptxInsertImageOperation, PptxInsertSlideOperation, PptxInsertTableOperation, PptxInsertTextBoxOperation, PptxLayoutInfo, PptxMoveElementOperation, PptxMoveSlideOperation, PptxOperation, PptxReplaceTextOperation, PptxResizeElementOperation, PptxSaveOptions, PptxSetShapeStyleOperation, PptxSetTableCellOperation, PptxSetTextStyleOperation, PptxSlideInfo } from "./types.js";
+/**
+ * The PPTX session: the core session narrowed to PPTX operations and
+ * elements, plus the slide and layout reads. Each typed method is `apply()`
+ * with a single operation.
+ */
+export declare class PptxSession implements PptxEditSession {
+    #private;
+    readonly format: "pptx";
+    constructor(core: EditSessionCore);
+    get sessionId(): string;
+    get state(): EditState;
+    get schemas(): OperationSchemaSet;
+    apply(operations: readonly PptxOperation[], options?: ApplyOptions): Promise<EditReceipt>;
+    applyJson(operations: readonly EditOperation[], options?: ApplyOptions): Promise<EditReceipt>;
+    undo(options?: HistoryOptions): Promise<EditReceipt>;
+    redo(options?: HistoryOptions): Promise<EditReceipt>;
+    reset(options?: HistoryOptions): Promise<EditReceipt>;
+    save(options?: PptxSaveOptions): Promise<SavedDocument>;
+    markSaved(stateToken: string): void;
+    addAsset(data: Uint8Array, options?: AssetOptions): Promise<string>;
+    getElements(query?: ElementQuery, options?: ReadOptions): Promise<ReadResult<PptxElement>>;
+    getElement(id: string, options?: ReadOptions): Promise<ReadItem<PptxElement>>;
+    elementsAt(pageIndex: number, point: PagePoint, options?: ReadOptions): Promise<ReadResult<PptxElement>>;
+    findText(query: string, options?: EditFindOptions): Promise<ReadResult<TextTarget>>;
+    getOutline(options?: OutlineOptions): Promise<OutlineResult>;
+    describe(options?: DescribeOptions): Promise<ReadItem<DocumentDescription>>;
+    resolveTargets(query: TargetQuery, options?: ReadOptions): Promise<ReadResult<TargetCandidate>>;
+    createCheckpoint(label?: string): Promise<EditCheckpoint>;
+    listCheckpoints(): readonly EditCheckpoint[];
+    restoreCheckpoint(id: string, options?: HistoryOptions): Promise<EditReceipt>;
+    dropCheckpoint(id: string): void;
+    get tools(): ToolSet;
+    callTool(call: ToolCall, options?: ToolCallOptions): Promise<ToolResult>;
+    getSlides(options?: ReadOptions): Promise<ReadResult<PptxSlideInfo>>;
+    getLayouts(options?: ReadOptions): Promise<ReadResult<PptxLayoutInfo>>;
+    replaceText(fields: PptxFields<PptxReplaceTextOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    setTextStyle(fields: PptxFields<PptxSetTextStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    setShapeStyle(fields: PptxFields<PptxSetShapeStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    moveElement(fields: PptxFields<PptxMoveElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    resizeElement(fields: PptxFields<PptxResizeElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    deleteElement(fields: PptxFields<PptxDeleteElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    insertTextBox(fields: PptxFields<PptxInsertTextBoxOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    insertImage(fields: PptxFields<PptxInsertImageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    insertTable(fields: PptxFields<PptxInsertTableOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    setTableCell(fields: PptxFields<PptxSetTableCellOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    insertSlide(fields: PptxFields<PptxInsertSlideOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    duplicateSlide(fields: PptxFields<PptxDuplicateSlideOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    deleteSlide(fields: PptxFields<PptxDeleteSlideOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    moveSlide(fields: PptxFields<PptxMoveSlideOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+}