web-doc 0.6.2 → 0.7.0

package/dist/edit/pdf/range-map.d.ts

@@ -0,0 +1,14 @@
+import type { EditOperation, EditReceipt, TextRange } from "../types.js";
+export interface MutationRecord {
+    /** The revision the call produced. */
+    readonly revision: number;
+    readonly kind: "apply" | "undo" | "redo" | "reset";
+    /**
+     * The operations the call applied (apply, redo) or took back (undo, reset);
+     * for a reset every batch of the session, in order.
+     */
+    readonly operations: readonly EditOperation[];
+    readonly receipt: EditReceipt;
+}
+/** The range after the records, or `undefined` when its element is gone. */
+export declare function mapRangeThrough(range: TextRange, records: readonly MutationRecord[]): TextRange | undefined;

package/dist/edit/pdf/range-map.js

@@ -0,0 +1,107 @@
+/** The range after the records, or `undefined` when its element is gone. */
+export function mapRangeThrough(range, records) {
+    const start = carry(range.start, records);
+    const end = carry(range.end, records);
+    if (start.gone || end.gone)
+        return undefined;
+    if (start.position.elementId === end.position.elementId &&
+        end.position.offset < start.position.offset)
+        return { start: start.position, end: start.position };
+    return { start: start.position, end: end.position };
+}
+function carry(position, records) {
+    const carried = { position, gone: false };
+    for (const record of records) {
+        const forward = record.kind === "apply" || record.kind === "redo";
+        const operations = forward
+            ? record.operations
+            : [...record.operations].reverse();
+        for (const operation of operations) {
+            if (forward)
+                applyForward(carried, operation);
+            else
+                applyBackward(carried, operation);
+        }
+        const { receipt } = record;
+        const id = carried.position.elementId;
+        if (receipt.removedIds.includes(id))
+            carried.gone = true;
+        if (receipt.createdIds.includes(id))
+            carried.gone = false;
+        const renamed = receipt.remappedIds?.[id];
+        if (renamed)
+            carried.position = { ...carried.position, elementId: renamed };
+    }
+    return carried;
+}
+function applyForward(carried, operation) {
+    const id = carried.position.elementId;
+    if (operation.op === "deleteElement" && targetOf(operation) === id) {
+        carried.gone = true;
+        return;
+    }
+    const replace = asReplace(operation, id);
+    if (!replace)
+        return;
+    const { offset } = carried.position;
+    const span = spanOf(replace);
+    // A whole-text replacement: offsets stay and the live element bounds them.
+    if (!span)
+        return;
+    const delta = replace.text.length - (span.end - span.start);
+    carried.position = {
+        elementId: id,
+        offset: offset <= span.start
+            ? offset
+            : offset >= span.end
+                ? offset + delta
+                : Math.min(offset, span.start + replace.text.length),
+    };
+}
+function applyBackward(carried, operation) {
+    const id = carried.position.elementId;
+    if (operation.op === "deleteElement" && targetOf(operation) === id) {
+        carried.gone = false;
+        return;
+    }
+    const replace = asReplace(operation, id);
+    if (!replace)
+        return;
+    const span = spanOf(replace);
+    // A whole-text replacement taken back: the old length is unknown here.
+    if (!span)
+        return;
+    const { offset } = carried.position;
+    const newEnd = span.start + replace.text.length;
+    const delta = span.end - span.start - replace.text.length;
+    carried.position = {
+        elementId: id,
+        offset: offset <= span.start
+            ? offset
+            : offset >= newEnd
+                ? offset + delta
+                : Math.min(offset, span.end),
+    };
+}
+function asReplace(operation, elementId) {
+    if (operation.op !== "replaceText")
+        return undefined;
+    const candidate = operation;
+    if (candidate.target !== elementId || typeof candidate.text !== "string")
+        return undefined;
+    return candidate;
+}
+function spanOf(replace) {
+    const { range } = replace;
+    if (!range ||
+        range.start.elementId !== replace.target ||
+        range.end.elementId !== replace.target)
+        return undefined;
+    return {
+        start: Math.min(range.start.offset, range.end.offset),
+        end: Math.max(range.start.offset, range.end.offset),
+    };
+}
+function targetOf(operation) {
+    return operation.target;
+}

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

@@ -0,0 +1,11 @@
+import type { JsonSchema, OperationSchemaSet } from "../types.js";
+export declare const pdfOperationSchemas: OperationSchemaSet;
+/**
+ * What a `WebDoc` mark found in a file must look like before its objects are
+ * treated as one of web-doc's own elements. Anything else stays plain objects.
+ */
+/** The head mark of a table, on its path objects, holding every input. */
+export declare const tableMarkSchema: JsonSchema;
+/** The mark on a table's text objects: the id alone. */
+export declare const tableMemberMarkSchema: JsonSchema;
+export declare const textBoxMarkSchema: JsonSchema;

package/dist/edit/pdf/schemas.js

@@ -0,0 +1,291 @@
+/*
+ * JSON Schemas of the PDF 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.
+ */
+const definitions = {
+    rect: {
+        type: "object",
+        required: ["x", "y", "width", "height"],
+        additionalProperties: false,
+        properties: {
+            x: { type: "number" },
+            y: { type: "number" },
+            width: { type: "number", exclusiveMinimum: 0 },
+            height: { type: "number", exclusiveMinimum: 0 },
+        },
+    },
+    color: { type: "string", pattern: "^#[0-9A-Fa-f]{6}$" },
+    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" },
+        },
+    },
+    point: {
+        type: "object",
+        required: ["x", "y"],
+        additionalProperties: false,
+        properties: { x: { type: "number" }, y: { type: "number" } },
+    },
+    offset: {
+        type: "object",
+        required: ["dx", "dy"],
+        additionalProperties: false,
+        properties: { dx: { type: "number" }, dy: { type: "number" } },
+    },
+    stroke: {
+        type: "object",
+        required: ["color", "width"],
+        additionalProperties: false,
+        properties: {
+            color: { $ref: "#/$defs/color" },
+            width: { type: "number", minimum: 0, maximum: 100 },
+        },
+    },
+    fill: {
+        type: "object",
+        required: ["color"],
+        additionalProperties: false,
+        properties: { color: { $ref: "#/$defs/color" } },
+    },
+    strokeOrNull: {
+        type: ["object", "null"],
+        required: ["color", "width"],
+        additionalProperties: false,
+        properties: {
+            color: { $ref: "#/$defs/color" },
+            width: { type: "number", minimum: 0, maximum: 100 },
+        },
+    },
+    fillOrNull: {
+        type: ["object", "null"],
+        required: ["color"],
+        additionalProperties: false,
+        properties: { color: { $ref: "#/$defs/color" } },
+    },
+    textBoxStyle: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            fontFamily: { type: "string", minLength: 1, maxLength: 100 },
+            fontSize: { type: "number", minimum: 1, maximum: 500 },
+            bold: { type: "boolean" },
+            italic: { type: "boolean" },
+            color: { $ref: "#/$defs/color" },
+            align: { enum: ["left", "center", "right"] },
+            lineHeight: { type: "number", minimum: 0.5, maximum: 5 },
+        },
+    },
+    tableStyle: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            fontFamily: { type: "string", minLength: 1, maxLength: 100 },
+            fontSize: { type: "number", minimum: 1, maximum: 500 },
+            color: { $ref: "#/$defs/color" },
+            borderColor: { $ref: "#/$defs/color" },
+            borderWidth: { type: "number", minimum: 0, maximum: 20 },
+            cellPadding: { type: "number", minimum: 0, maximum: 100 },
+            headerFill: { $ref: "#/$defs/color" },
+        },
+    },
+    tableRows: {
+        type: "array",
+        minItems: 1,
+        maxItems: 100,
+        items: {
+            type: "array",
+            minItems: 1,
+            maxItems: 20,
+            items: { type: "string", maxLength: 2000 },
+        },
+    },
+};
+function operation(name, properties, required) {
+    return {
+        type: "object",
+        required: ["op", ...required],
+        additionalProperties: false,
+        properties: { op: { const: name }, ...properties },
+        $defs: definitions,
+    };
+}
+export const pdfOperationSchemas = Object.freeze({
+    format: "pdf",
+    version: 1,
+    operations: Object.freeze({
+        insertTextBox: operation("insertTextBox", {
+            pageIndex: { type: "integer", minimum: 0 },
+            rect: { $ref: "#/$defs/rect" },
+            text: { type: "string", minLength: 1, maxLength: 20000 },
+            style: { $ref: "#/$defs/textBoxStyle" },
+        }, ["pageIndex", "rect", "text"]),
+        replaceText: operation("replaceText", {
+            target: { $ref: "#/$defs/target" },
+            text: { type: "string", minLength: 1, maxLength: 20000 },
+            range: { $ref: "#/$defs/textRange" },
+        }, ["target", "text"]),
+        setTextStyle: operation("setTextStyle", {
+            target: { $ref: "#/$defs/target" },
+            style: { $ref: "#/$defs/textBoxStyle" },
+        }, ["target", "style"]),
+        resizeElement: operation("resizeElement", {
+            target: { $ref: "#/$defs/target" },
+            rect: { $ref: "#/$defs/rect" },
+        }, ["target", "rect"]),
+        moveElement: operation("moveElement", {
+            target: { $ref: "#/$defs/target" },
+            to: { $ref: "#/$defs/point" },
+            by: { $ref: "#/$defs/offset" },
+        }, ["target"]),
+        deleteElement: operation("deleteElement", { target: { $ref: "#/$defs/target" } }, ["target"]),
+        insertPage: operation("insertPage", {
+            index: { type: "integer", minimum: 0 },
+            size: {
+                type: "object",
+                required: ["width", "height"],
+                additionalProperties: false,
+                properties: {
+                    width: { type: "number", minimum: 3, maximum: 14400 },
+                    height: { type: "number", minimum: 3, maximum: 14400 },
+                },
+            },
+        }, ["index"]),
+        deletePage: operation("deletePage", { pageIndex: { type: "integer", minimum: 0 } }, ["pageIndex"]),
+        movePage: operation("movePage", {
+            from: { type: "integer", minimum: 0 },
+            to: { type: "integer", minimum: 0 },
+        }, ["from", "to"]),
+        rotatePage: operation("rotatePage", {
+            pageIndex: { type: "integer", minimum: 0 },
+            rotation: { enum: [0, 90, 180, 270] },
+        }, ["pageIndex", "rotation"]),
+        insertShape: operation("insertShape", {
+            pageIndex: { type: "integer", minimum: 0 },
+            shape: { enum: ["rectangle", "ellipse", "line"] },
+            rect: { $ref: "#/$defs/rect" },
+            from: { $ref: "#/$defs/point" },
+            to: { $ref: "#/$defs/point" },
+            stroke: { $ref: "#/$defs/stroke" },
+            fill: { $ref: "#/$defs/fill" },
+        }, ["pageIndex", "shape"]),
+        setShapeStyle: operation("setShapeStyle", {
+            target: { $ref: "#/$defs/target" },
+            stroke: { $ref: "#/$defs/strokeOrNull" },
+            fill: { $ref: "#/$defs/fillOrNull" },
+        }, ["target"]),
+        insertImage: operation("insertImage", {
+            pageIndex: { type: "integer", minimum: 0 },
+            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: { type: "integer", minimum: 0 },
+            at: { $ref: "#/$defs/point" },
+            width: { type: "number", exclusiveMinimum: 0 },
+            rows: { $ref: "#/$defs/tableRows" },
+            columnWidths: {
+                type: "array",
+                minItems: 1,
+                maxItems: 20,
+                items: { type: "number", exclusiveMinimum: 0 },
+            },
+            style: { $ref: "#/$defs/tableStyle" },
+        }, ["pageIndex", "at", "width", "rows"]),
+        setTableCell: operation("setTableCell", {
+            target: { $ref: "#/$defs/target" },
+            row: { type: "integer", minimum: 0 },
+            column: { type: "integer", minimum: 0 },
+            text: { type: "string", maxLength: 2000 },
+        }, ["target", "row", "column", "text"]),
+    }),
+});
+/**
+ * What a `WebDoc` mark found in a file must look like before its objects are
+ * treated as one of web-doc's own elements. Anything else stays plain objects.
+ */
+/** The head mark of a table, on its path objects, holding every input. */
+export const tableMarkSchema = {
+    type: "object",
+    required: ["kind", "id", "at", "rows", "columnWidths", "style"],
+    additionalProperties: false,
+    properties: {
+        kind: { const: "table" },
+        id: { $ref: "#/$defs/target" },
+        at: { $ref: "#/$defs/point" },
+        rows: { $ref: "#/$defs/tableRows" },
+        columnWidths: {
+            type: "array",
+            minItems: 1,
+            maxItems: 20,
+            items: { type: "number", exclusiveMinimum: 0 },
+        },
+        style: {
+            type: "object",
+            required: [
+                "fontFamily",
+                "fontSize",
+                "color",
+                "borderColor",
+                "borderWidth",
+                "cellPadding",
+                "headerFill",
+            ],
+            additionalProperties: false,
+            properties: {
+                ...definitions.tableStyle.properties,
+                headerFill: { type: ["string", "null"], pattern: "^#[0-9A-Fa-f]{6}$" },
+            },
+        },
+    },
+    $defs: definitions,
+};
+/** The mark on a table's text objects: the id alone. */
+export const tableMemberMarkSchema = {
+    type: "object",
+    required: ["kind", "id"],
+    additionalProperties: false,
+    properties: { kind: { const: "table" }, id: { $ref: "#/$defs/target" } },
+    $defs: definitions,
+};
+export const textBoxMarkSchema = {
+    type: "object",
+    required: ["kind", "id", "rect", "text", "style"],
+    additionalProperties: false,
+    properties: {
+        kind: { const: "textBox" },
+        id: { $ref: "#/$defs/target" },
+        rect: { $ref: "#/$defs/rect" },
+        text: { type: "string", minLength: 1, maxLength: 20000 },
+        style: {
+            type: "object",
+            required: [
+                "fontFamily",
+                "fontSize",
+                "bold",
+                "italic",
+                "color",
+                "align",
+                "lineHeight",
+            ],
+            additionalProperties: false,
+            properties: definitions.textBoxStyle.properties,
+        },
+    },
+    $defs: definitions,
+};

package/dist/edit/pdf/selection.d.ts

@@ -0,0 +1,5 @@
+import type { TextSelection } from "../../contracts.js";
+import type { TextRange } from "../types.js";
+import type { PageLayout } from "./types.js";
+/** Ranges of the selected text, merged per element, in reading order. */
+export declare function resolveSelection(selection: TextSelection, pages: readonly PageLayout[]): TextRange[];

package/dist/edit/pdf/selection.js

@@ -0,0 +1,152 @@
+import { normalizeWithMap } from "../../search-text.js";
+/** Slack, in points, when a run's box is compared with a line's. */
+const SLACK = 0.5;
+/** Ranges of the selected text, merged per element, in reading order. */
+export function resolveSelection(selection, pages) {
+    const candidates = [];
+    for (const page of pages)
+        for (const layout of page.layouts)
+            for (const line of layout.lines)
+                candidates.push({
+                    order: candidates.length,
+                    elementId: layout.elementId,
+                    line,
+                });
+    const found = [];
+    for (const run of selection.runs) {
+        if (!run.text.trim())
+            continue;
+        const match = matchRun(run, candidates);
+        if (!match)
+            continue;
+        const range = rangeWithin(run, match.line, match.elementId);
+        if (range)
+            found.push({ order: match.order, range });
+    }
+    return merge(found);
+}
+function matchRun(run, candidates) {
+    const box = { x: run.x, y: run.y, width: run.width, height: run.height };
+    // 1. The line whose box the run covers by at least half.
+    let best;
+    let bestOverlap = 0;
+    for (const candidate of candidates) {
+        const overlap = overlapArea(box, candidate.line.bounds);
+        if (overlap >= area(candidate.line.bounds) / 2 && overlap > bestOverlap) {
+            best = candidate;
+            bestOverlap = overlap;
+        }
+    }
+    if (best)
+        return best;
+    // 2. The single line that contains the run's box.
+    const containing = candidates.filter((candidate) => contains(candidate.line.bounds, box));
+    if (containing.length > 0)
+        return containing.reduce((smallest, candidate) => area(candidate.line.bounds) < area(smallest.line.bounds)
+            ? candidate
+            : smallest);
+    // 3. A line whose folded text contains the run's folded text.
+    const needle = fold(run.text).text;
+    if (!needle)
+        return undefined;
+    return candidates.find((candidate) => fold(candidate.line.text).text.includes(needle));
+}
+/**
+ * The part of the line the run covers. The run's text decides when it occurs
+ * in the line — the viewer cuts runs proportionally, so their boxes are only
+ * approximate — and its box picks the occurrence nearest to the glyphs it
+ * covers; without a textual match the covered glyphs stand on their own.
+ */
+function rangeWithin(run, line, elementId) {
+    const box = { x: run.x, y: run.y, width: run.width, height: run.height };
+    const covered = line.glyphs
+        .filter((glyph) => contains(grow(box, SLACK), centre(glyph.box)))
+        .map((glyph) => glyph.offset);
+    const anchor = covered.length > 0 ? Math.min(...covered) : line.range.start.offset;
+    const haystack = fold(line.text);
+    const needle = fold(run.text).text;
+    const base = line.range.start.offset;
+    let best;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (let at = needle ? haystack.text.indexOf(needle) : -1; at >= 0; at = haystack.text.indexOf(needle, at + 1)) {
+        const start = base + haystack.starts[at];
+        const distance = Math.abs(start - anchor);
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = {
+                start: { elementId, offset: start },
+                end: {
+                    elementId,
+                    offset: base + haystack.ends[at + needle.length - 1],
+                },
+            };
+        }
+    }
+    if (best)
+        return best;
+    if (covered.length === 0)
+        return undefined;
+    return {
+        start: { elementId, offset: Math.min(...covered) },
+        end: { elementId, offset: Math.max(...covered) + 1 },
+    };
+}
+/** NFKC-folded text without whitespace, with each folded unit's source offsets. */
+function fold(text) {
+    const mapped = normalizeWithMap(text, false);
+    let folded = "";
+    const starts = [];
+    const ends = [];
+    for (let index = 0; index < mapped.text.length; index += 1) {
+        const unit = mapped.text[index];
+        if (/\s/u.test(unit))
+            continue;
+        folded += unit;
+        starts.push(mapped.starts[index]);
+        ends.push(mapped.ends[index]);
+    }
+    return { text: folded, starts, ends };
+}
+function merge(found) {
+    const sorted = [...found].sort((a, b) => a.order - b.order || a.range.start.offset - b.range.start.offset);
+    const merged = [];
+    for (const { range } of sorted) {
+        const last = merged.at(-1);
+        if (last &&
+            last.end.elementId === range.start.elementId &&
+            range.start.offset <= last.end.offset) {
+            if (range.end.offset > last.end.offset)
+                merged[merged.length - 1] = { start: last.start, end: range.end };
+        }
+        else
+            merged.push(range);
+    }
+    return merged;
+}
+function area(rect) {
+    return Math.max(0, rect.width) * Math.max(0, rect.height);
+}
+function overlapArea(a, b) {
+    const width = Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x);
+    const height = Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y);
+    return width > 0 && height > 0 ? width * height : 0;
+}
+function contains(outer, inner) {
+    const width = "width" in inner ? inner.width : 0;
+    const height = "height" in inner ? inner.height : 0;
+    return (inner.x >= outer.x - SLACK &&
+        inner.y >= outer.y - SLACK &&
+        inner.x + width <= outer.x + outer.width + SLACK &&
+        inner.y + height <= outer.y + outer.height + SLACK);
+}
+function grow(rect, by) {
+    return {
+        x: rect.x - by,
+        y: rect.y - by,
+        width: rect.width + 2 * by,
+        height: rect.height + 2 * by,
+    };
+}
+function centre(rect) {
+    return { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 };
+}

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

@@ -0,0 +1,53 @@
+import type { TextSelection } from "../../contracts.js";
+import type { EditSessionCore } from "../engine.js";
+import type { ApplyOptions, AssetOptions, EditFindOptions, EditOperation, EditReceipt, EditState, ElementQuery, HistoryOptions, OperationSchemaSet, PagePoint, PageRect, ReadItem, ReadOptions, ReadResult, SavedDocument, TextPosition, TextRange, TextTarget } from "../types.js";
+import type { DeleteElementOperation, DeletePageOperation, Fields, InsertImageOperation, InsertPageOperation, InsertShapeOperation, InsertTableOperation, InsertTextBoxOperation, MoveElementOperation, MovePageOperation, PdfEditSession, PdfElement, PdfOperation, PdfSaveOptions, ReplaceTextOperation, ResizeElementOperation, RotatePageOperation, SetShapeStyleOperation, SetTableCellOperation, PageBitmap, PageLayout, RenderOptions, SetTextStyleOperation, TextLayout } from "./types.js";
+/**
+ * The PDF session: the core session narrowed to PDF operations and elements.
+ * Typed methods are added here as their operations ship; each is `apply()`
+ * with a single operation.
+ */
+export declare class PdfSession implements PdfEditSession {
+    #private;
+    readonly format: "pdf";
+    constructor(core: EditSessionCore);
+    get sessionId(): string;
+    get state(): EditState;
+    get schemas(): OperationSchemaSet;
+    apply(operations: readonly PdfOperation[], 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?: PdfSaveOptions): Promise<SavedDocument>;
+    markSaved(stateToken: string): void;
+    addAsset(data: Uint8Array, options?: AssetOptions): Promise<string>;
+    getElements(query?: ElementQuery, options?: ReadOptions): Promise<ReadResult<PdfElement>>;
+    elementsAtSync(pageIndex: number, point: PagePoint): ReadResult<PdfElement>;
+    get cachedPages(): readonly number[];
+    getElement(id: string, options?: ReadOptions): Promise<ReadItem<PdfElement>>;
+    elementsAt(pageIndex: number, point: PagePoint, options?: ReadOptions): Promise<ReadResult<PdfElement>>;
+    findText(query: string, options?: EditFindOptions): Promise<ReadResult<TextTarget>>;
+    getTextLayout(elementId: string, options?: ReadOptions): Promise<ReadItem<TextLayout>>;
+    positionAt(pageIndex: number, point: PagePoint, options?: ReadOptions): Promise<ReadItem<TextPosition>>;
+    rangeRects(range: TextRange, options?: ReadOptions): Promise<ReadResult<PageRect>>;
+    getPageLayout(pageIndex: number, options?: ReadOptions): Promise<ReadItem<PageLayout>>;
+    elementsForSelection(selection: TextSelection, options?: ReadOptions): Promise<ReadResult<TextRange>>;
+    mapRange(range: TextRange, fromRevision: number, options?: ReadOptions): Promise<ReadItem<TextRange>>;
+    renderPageWithout(pageIndex: number, elementIds: readonly string[], options?: RenderOptions): Promise<ReadItem<PageBitmap>>;
+    insertTextBox(fields: Fields<InsertTextBoxOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    replaceText(fields: Fields<ReplaceTextOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    setTextStyle(fields: Fields<SetTextStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    resizeElement(fields: Fields<ResizeElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    moveElement(fields: Fields<MoveElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    deleteElement(fields: Fields<DeleteElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    insertPage(fields: Fields<InsertPageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    deletePage(fields: Fields<DeletePageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    movePage(fields: Fields<MovePageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    rotatePage(fields: Fields<RotatePageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    insertShape(fields: Fields<InsertShapeOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    setShapeStyle(fields: Fields<SetShapeStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    insertImage(fields: Fields<InsertImageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    insertTable(fields: Fields<InsertTableOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    setTableCell(fields: Fields<SetTableCellOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+}