@progress/kendo-pdfviewer-common 0.3.0-dev.202409251459 → 0.3.0-dev.202410100645

package/dist/npm/annotations/draw-layer-builder.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @typedef {Object} DrawLayerBuilderOptions
+ * @property {number} pageIndex
+ */
+declare class DrawLayerBuilder {
+    #private;
+    pageIndex: number;
+    _cancelled: boolean;
+    /**
+     * @param {DrawLayerBuilderOptions} options
+     */
+    constructor(options: any);
+    /**
+     * @param {string} intent (default value is 'display')
+     */
+    render(intent?: string): Promise<void>;
+    cancel(): void;
+    setParent(parent: any): void;
+    getDrawLayer(): any;
+}
+export { DrawLayerBuilder };

package/dist/npm/annotations/draw-layer-builder.js

@@ -0,0 +1,68 @@
+"use strict";
+/* Copyright 2022 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var _DrawLayerBuilder_drawLayer;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawLayerBuilder = void 0;
+const tslib_1 = require("tslib");
+const draw_layer_1 = require("./draw-layer");
+/**
+ * @typedef {Object} DrawLayerBuilderOptions
+ * @property {number} pageIndex
+ */
+class DrawLayerBuilder {
+    /**
+     * @param {DrawLayerBuilderOptions} options
+     */
+    constructor(options) {
+        // todo: props
+        this.pageIndex = null;
+        this._cancelled = null;
+        // todo: props
+        _DrawLayerBuilder_drawLayer.set(this, null);
+        this.pageIndex = options.pageIndex;
+    }
+    /**
+     * @param {string} intent (default value is 'display')
+     */
+    render() {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (intent = "display") {
+            // if (intent !== "display" || this.#drawLayer || this._cancelled) {
+            if (intent !== "display" || tslib_1.__classPrivateFieldGet(this, _DrawLayerBuilder_drawLayer, "f")) {
+                return;
+            }
+            tslib_1.__classPrivateFieldSet(this, _DrawLayerBuilder_drawLayer, new draw_layer_1.DrawLayer({
+                pageIndex: this.pageIndex,
+            }), "f");
+        });
+    }
+    cancel() {
+        // this._cancelled = true;
+        if (!tslib_1.__classPrivateFieldGet(this, _DrawLayerBuilder_drawLayer, "f")) {
+            return;
+        }
+        tslib_1.__classPrivateFieldGet(this, _DrawLayerBuilder_drawLayer, "f").destroy();
+        tslib_1.__classPrivateFieldSet(this, _DrawLayerBuilder_drawLayer, null, "f");
+    }
+    setParent(parent) {
+        var _a;
+        (_a = tslib_1.__classPrivateFieldGet(this, _DrawLayerBuilder_drawLayer, "f")) === null || _a === void 0 ? void 0 : _a.setParent(parent);
+    }
+    getDrawLayer() {
+        return tslib_1.__classPrivateFieldGet(this, _DrawLayerBuilder_drawLayer, "f");
+    }
+}
+exports.DrawLayerBuilder = DrawLayerBuilder;
+_DrawLayerBuilder_drawLayer = new WeakMap();

package/dist/npm/annotations/draw-layer.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Manage the SVGs drawn on top of the page canvas.
+ * It's important to have them directly on top of the canvas because we want to
+ * be able to use mix-blend-mode for some of them.
+ */
+declare class DrawLayer {
+    #private;
+    pageIndex: number;
+    constructor({ pageIndex }: {
+        pageIndex: any;
+    });
+    setParent(parent: any): void;
+    static get _svgFactory(): any;
+    highlight(outlines: any, color: any, opacity: any, isPathUpdatable?: boolean): {
+        id: number;
+        clipPathId: string;
+    };
+    highlightOutline(outlines: any): number;
+    finalizeLine(id: any, line: any): void;
+    updateLine(id: any, line: any): void;
+    removeFreeHighlight(id: any): void;
+    updatePath(id: any, line: any): void;
+    updateBox(id: any, box: any): void;
+    show(id: any, visible: any): void;
+    rotate(id: any, angle: any): void;
+    changeColor(id: any, color: any): void;
+    changeOpacity(id: any, opacity: any): void;
+    addClass(id: any, className: any): void;
+    removeClass(id: any, className: any): void;
+    remove(id: any): void;
+    destroy(): void;
+}
+export { DrawLayer };

package/dist/npm/annotations/draw-layer.js

@@ -0,0 +1,223 @@
+"use strict";
+/* Copyright 2023 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var _DrawLayer_instances, _a, _DrawLayer_parent, _DrawLayer_id, _DrawLayer_mapping, _DrawLayer_toUpdate, _DrawLayer_setBox, _DrawLayer_createSVG, _DrawLayer_createClipPath;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawLayer = void 0;
+const tslib_1 = require("tslib");
+// import { DOMSVGFactory } from "./display_utils.js";
+// import { shadow } from "../shared/util.js";
+const pdf_mjs_1 = require("pdfjs-dist/legacy/build/pdf.mjs");
+/**
+ * Manage the SVGs drawn on top of the page canvas.
+ * It's important to have them directly on top of the canvas because we want to
+ * be able to use mix-blend-mode for some of them.
+ */
+class DrawLayer {
+    constructor({ pageIndex }) {
+        _DrawLayer_instances.add(this);
+        // todo: props
+        this.pageIndex = 0;
+        // todo: props
+        _DrawLayer_parent.set(this, null);
+        _DrawLayer_id.set(this, 0);
+        _DrawLayer_mapping.set(this, new Map());
+        _DrawLayer_toUpdate.set(this, new Map());
+        this.pageIndex = pageIndex;
+    }
+    setParent(parent) {
+        if (!tslib_1.__classPrivateFieldGet(this, _DrawLayer_parent, "f")) {
+            tslib_1.__classPrivateFieldSet(this, _DrawLayer_parent, parent, "f");
+            return;
+        }
+        if (tslib_1.__classPrivateFieldGet(this, _DrawLayer_parent, "f") !== parent) {
+            if (tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").size > 0) {
+                for (const root of tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").values()) {
+                    root.remove();
+                    parent.append(root);
+                }
+            }
+            tslib_1.__classPrivateFieldSet(this, _DrawLayer_parent, parent, "f");
+        }
+    }
+    static get _svgFactory() {
+        return (0, pdf_mjs_1.shadow)(this, "_svgFactory", new pdf_mjs_1.DOMSVGFactory());
+    }
+    highlight(outlines, color, opacity, isPathUpdatable = false) {
+        var _b, _c;
+        const id = (tslib_1.__classPrivateFieldSet(this, _DrawLayer_id, (_c = tslib_1.__classPrivateFieldGet(this, _DrawLayer_id, "f"), _b = _c++, _c), "f"), _b);
+        const root = tslib_1.__classPrivateFieldGet(this, _DrawLayer_instances, "m", _DrawLayer_createSVG).call(this, outlines.box);
+        // root.classList.add("highlight");
+        root.classList.add("k-highlight");
+        if (outlines.free) {
+            // root.classList.add("free");
+        }
+        const defs = _a._svgFactory.createElement("defs");
+        root.append(defs);
+        const path = _a._svgFactory.createElement("path");
+        defs.append(path);
+        const pathId = `path_p${this.pageIndex}_${id}`;
+        path.setAttribute("id", pathId);
+        path.setAttribute("d", outlines.toSVGPath());
+        if (isPathUpdatable) {
+            tslib_1.__classPrivateFieldGet(this, _DrawLayer_toUpdate, "f").set(id, path);
+        }
+        // Create the clipping path for the editor div.
+        const clipPathId = tslib_1.__classPrivateFieldGet(this, _DrawLayer_instances, "m", _DrawLayer_createClipPath).call(this, defs, pathId);
+        const use = _a._svgFactory.createElement("use");
+        root.append(use);
+        root.setAttribute("fill", color);
+        root.setAttribute("fill-opacity", opacity);
+        use.setAttribute("href", `#${pathId}`);
+        tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").set(id, root);
+        return { id, clipPathId: `url(#${clipPathId})` };
+    }
+    highlightOutline(outlines) {
+        var _b, _c;
+        // We cannot draw the outline directly in the SVG for highlights because
+        // it composes with its parent with mix-blend-mode: multiply.
+        // But the outline has a different mix-blend-mode, so we need to draw it in
+        // its own SVG.
+        const id = (tslib_1.__classPrivateFieldSet(this, _DrawLayer_id, (_c = tslib_1.__classPrivateFieldGet(this, _DrawLayer_id, "f"), _b = _c++, _c), "f"), _b);
+        const root = tslib_1.__classPrivateFieldGet(this, _DrawLayer_instances, "m", _DrawLayer_createSVG).call(this, outlines.box);
+        // root.classList.add("highlightOutline");
+        root.classList.add("k-highlight-outline");
+        const defs = _a._svgFactory.createElement("defs");
+        root.append(defs);
+        const path = _a._svgFactory.createElement("path");
+        defs.append(path);
+        const pathId = `path_p${this.pageIndex}_${id}`;
+        path.setAttribute("id", pathId);
+        path.setAttribute("d", outlines.toSVGPath());
+        path.setAttribute("vector-effect", "non-scaling-stroke");
+        let maskId;
+        if (outlines.free) {
+            // root.classList.add("free");
+            const mask = _a._svgFactory.createElement("mask");
+            defs.append(mask);
+            maskId = `mask_p${this.pageIndex}_${id}`;
+            mask.setAttribute("id", maskId);
+            mask.setAttribute("maskUnits", "objectBoundingBox");
+            const rect = _a._svgFactory.createElement("rect");
+            mask.append(rect);
+            rect.setAttribute("width", "1");
+            rect.setAttribute("height", "1");
+            rect.setAttribute("fill", "white");
+            const use = _a._svgFactory.createElement("use");
+            mask.append(use);
+            use.setAttribute("href", `#${pathId}`);
+            use.setAttribute("stroke", "none");
+            use.setAttribute("fill", "black");
+            use.setAttribute("fill-rule", "nonzero");
+            // use.classList.add("mask");
+        }
+        const use1 = _a._svgFactory.createElement("use");
+        root.append(use1);
+        use1.setAttribute("href", `#${pathId}`);
+        if (maskId) {
+            use1.setAttribute("mask", `url(#${maskId})`);
+        }
+        const use2 = use1.cloneNode();
+        root.append(use2);
+        // use1.classList.add("mainOutline");
+        // use2.classList.add("secondaryOutline");
+        tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").set(id, root);
+        return id;
+    }
+    finalizeLine(id, line) {
+        const path = tslib_1.__classPrivateFieldGet(this, _DrawLayer_toUpdate, "f").get(id);
+        tslib_1.__classPrivateFieldGet(this, _DrawLayer_toUpdate, "f").delete(id);
+        this.updateBox(id, line.box);
+        path.setAttribute("d", line.toSVGPath());
+    }
+    updateLine(id, line) {
+        const root = tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").get(id);
+        const defs = root.firstChild;
+        const path = defs.firstChild;
+        path.setAttribute("d", line.toSVGPath());
+    }
+    removeFreeHighlight(id) {
+        this.remove(id);
+        tslib_1.__classPrivateFieldGet(this, _DrawLayer_toUpdate, "f").delete(id);
+    }
+    updatePath(id, line) {
+        tslib_1.__classPrivateFieldGet(this, _DrawLayer_toUpdate, "f").get(id).setAttribute("d", line.toSVGPath());
+    }
+    updateBox(id, box) {
+        tslib_1.__classPrivateFieldGet(_a, _a, "m", _DrawLayer_setBox).call(_a, tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").get(id), box);
+    }
+    show(id, visible) {
+        // this.#mapping.get(id).classList.toggle("hidden", !visible);
+        tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").get(id).classList.toggle("k-hidden", !visible);
+    }
+    rotate(id, angle) {
+        tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").get(id).setAttribute("data-main-rotation", angle);
+    }
+    changeColor(id, color) {
+        tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").get(id).setAttribute("fill", color);
+    }
+    changeOpacity(id, opacity) {
+        tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").get(id).setAttribute("fill-opacity", opacity);
+    }
+    addClass(id, className) {
+        tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").get(id).classList.add(className);
+    }
+    removeClass(id, className) {
+        tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").get(id).classList.remove(className);
+    }
+    remove(id) {
+        if (tslib_1.__classPrivateFieldGet(this, _DrawLayer_parent, "f") === null) {
+            return;
+        }
+        tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").get(id).remove();
+        tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").delete(id);
+    }
+    destroy() {
+        tslib_1.__classPrivateFieldSet(this, _DrawLayer_parent, null, "f");
+        for (const root of tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").values()) {
+            root.remove();
+        }
+        tslib_1.__classPrivateFieldGet(this, _DrawLayer_mapping, "f").clear();
+    }
+}
+exports.DrawLayer = DrawLayer;
+_a = DrawLayer, _DrawLayer_parent = new WeakMap(), _DrawLayer_id = new WeakMap(), _DrawLayer_mapping = new WeakMap(), _DrawLayer_toUpdate = new WeakMap(), _DrawLayer_instances = new WeakSet(), _DrawLayer_setBox = function _DrawLayer_setBox(element, { x = 0, y = 0, width = 1, height = 1 } = {}) {
+    const { style } = element;
+    style.top = `${100 * y}%`;
+    style.left = `${100 * x}%`;
+    // style.width = `${100 * width}%`;
+    // style.height = `${100 * height}%`;
+    // todo: reduce the dimensions, so that the annotation editor toolbar
+    // does not overlap the outline
+    style.width = `${100 * width - 0.2}%`;
+    style.height = `${100 * height - 0.2}%`;
+}, _DrawLayer_createSVG = function _DrawLayer_createSVG(box) {
+    const svg = _a._svgFactory.create(1, 1, /* skipDimensions = */ true);
+    tslib_1.__classPrivateFieldGet(this, _DrawLayer_parent, "f").append(svg);
+    svg.setAttribute("aria-hidden", true);
+    tslib_1.__classPrivateFieldGet(_a, _a, "m", _DrawLayer_setBox).call(_a, svg, box);
+    return svg;
+}, _DrawLayer_createClipPath = function _DrawLayer_createClipPath(defs, pathId) {
+    const clipPath = _a._svgFactory.createElement("clipPath");
+    defs.append(clipPath);
+    const clipPathId = `clip_${pathId}`;
+    clipPath.setAttribute("id", clipPathId);
+    clipPath.setAttribute("clipPathUnits", "objectBoundingBox");
+    const clipPathUse = _a._svgFactory.createElement("use");
+    clipPath.append(clipPathUse);
+    clipPathUse.setAttribute("href", `#${pathId}`);
+    // clipPathUse.classList.add("clip");
+    return clipPathId;
+};

package/dist/npm/annotations/editors/annotation-editor.d.ts

@@ -0,0 +1,349 @@
+import { IdManager } from "../helpers/id-manager";
+import { ColorManager } from "../helpers/color-manager";
+import { AnnotationEditorUIManager } from "../annotation-editor-ui-manager";
+export declare class AnnotationEditor {
+    #private;
+    parent: any;
+    id: any;
+    width: any;
+    height: any;
+    pageIndex: number;
+    name: string;
+    div: any;
+    annotationElementId: any;
+    _willKeepAspectRatio: boolean;
+    _structTreeParentId: any;
+    rotation: number;
+    pageRotation: number;
+    pageDimensions: any[];
+    pageTranslation: any[];
+    isAttachedToDOM: boolean;
+    deleted: boolean;
+    static idManager: IdManager;
+    _editToolbar: any;
+    _initialOptions: any;
+    _isVisible: boolean;
+    _uiManager: AnnotationEditorUIManager;
+    _focusEventsAllowed: boolean;
+    _l10nPromise: any;
+    static _borderLineWidth: number;
+    static _colorManager: ColorManager;
+    static _zIndex: number;
+    static _telemetryTimeout: number;
+    constructor(parameters: any);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get editorType(): any;
+    static get _defaultLineColor(): any;
+    static deleteAnnotationElement(editor: any): void;
+    static initialize(l10n: any, _uiManager: any, options: any): void;
+    /**
+     * Update the default parameters for this type of editor.
+     * @param {number} _type
+     * @param {*} _value
+     */
+    static updateDefaultParams(_type: any, _value: any): void;
+    /**
+     * Get the default properties to set in the UI for this type of editor.
+     * @returns {Array}
+     */
+    static get defaultPropertiesToUpdate(): any[];
+    /**
+     * Check if this kind of editor is able to handle the given mime type for
+     * pasting.
+     * @param {string} mime
+     * @returns {boolean}
+     */
+    static isHandlingMimeForPasting(mime: any): boolean;
+    /**
+     * Extract the data from the clipboard item and delegate the creation of the
+     * editor to the parent.
+     * @param {DataTransferItem} item
+     * @param {AnnotationEditorLayer} parent
+     */
+    static paste(item: any, parent: any): void;
+    /**
+     * Get the properties to update in the UI for this editor.
+     * @returns {Array}
+     */
+    get propertiesToUpdate(): any[];
+    get _isDraggable(): boolean;
+    set _isDraggable(value: boolean);
+    /**
+     * @returns {boolean} true if the editor handles the Enter key itself.
+     */
+    get isEnterHandled(): boolean;
+    center(): void;
+    /**
+     * Add some commands into the CommandManager (undo/redo stuff).
+     * @param {Object} params
+     */
+    addCommands(params: any): void;
+    get currentLayer(): any;
+    /**
+     * This editor will be behind the others.
+     */
+    setInBackground(): void;
+    /**
+     * This editor will be in the foreground.
+     */
+    setInForeground(): void;
+    setParent(parent: any): void;
+    /**
+     * onfocus callback.
+     */
+    focusin(event: any): void;
+    /**
+     * onblur callback.
+     * @param {FocusEvent} event
+     */
+    focusout(event: any): void;
+    commitOrRemove(): void;
+    /**
+     * Commit the data contained in this editor.
+     */
+    commit(): void;
+    addToAnnotationStorage(): void;
+    /**
+     * Set the editor position within its parent.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} tx - x-translation in screen coordinates.
+     * @param {number} ty - y-translation in screen coordinates.
+     */
+    setAt(x: any, y: any, tx: any, ty: any): void;
+    /**
+     * Translate the editor position within its parent.
+     * @param {number} x - x-translation in screen coordinates.
+     * @param {number} y - y-translation in screen coordinates.
+     */
+    translate(x: any, y: any): void;
+    /**
+     * Translate the editor position within its page and adjust the scroll
+     * in order to have the editor in the view.
+     * @param {number} x - x-translation in page coordinates.
+     * @param {number} y - y-translation in page coordinates.
+     */
+    translateInPage(x: any, y: any): void;
+    drag(tx: any, ty: any): void;
+    get _hasBeenMoved(): boolean;
+    /**
+     * Get the translation to take into account the editor border.
+     * The CSS engine positions the element by taking the border into account so
+     * we must apply the opposite translation to have the editor in the right
+     * position.
+     * @returns {Array<number>}
+     */
+    getBaseTranslation(): number[];
+    /**
+     * @returns {boolean} true if position must be fixed (i.e. make the x and y
+     * living in the page).
+     */
+    get _mustFixPosition(): boolean;
+    /**
+     * Fix the position of the editor in order to keep it inside its parent page.
+     * @param {number} [rotation] - the rotation of the page.
+     */
+    fixAndSetPosition(rotation?: number): void;
+    /**
+     * Convert a screen translation into a page one.
+     * @param {number} x
+     * @param {number} y
+     */
+    screenToPageTranslation(x: any, y: any): any[];
+    /**
+     * Convert a page translation into a screen one.
+     * @param {number} x
+     * @param {number} y
+     */
+    pageTranslationToScreen(x: any, y: any): any[];
+    get parentScale(): any;
+    get parentRotation(): number;
+    get parentDimensions(): number[];
+    /**
+     * Set the dimensions of this editor.
+     * @param {number} width
+     * @param {number} height
+     */
+    setDims(width: any, height: any): void;
+    fixDims(): void;
+    /**
+     * Get the translation used to position this editor when it's created.
+     * @returns {Array<number>}
+     */
+    getInitialTranslation(): number[];
+    addEditToolbar(): void;
+    removeEditToolbar(): void;
+    getClientDimensions(): any;
+    /**
+     * Render this editor in a div.
+     * @returns {HTMLDivElement | null}
+     */
+    render(): any;
+    /**
+     * Onpointerdown callback.
+     * @param {PointerEvent} event
+     */
+    pointerdown(event: any): void;
+    moveInDOM(): void;
+    _setParentAndPosition(parent: any, x: any, y: any): void;
+    getRect(tx: any, ty: any, rotation?: number): any[];
+    getRectInCurrentCoords(rect: any, pageHeight: any): any[];
+    onceAdded(): void;
+    isEmpty(): boolean;
+    /**
+     * Enable edit mode.
+     */
+    enableEditMode(): void;
+    /**
+     * Disable edit mode.
+     */
+    disableEditMode(): void;
+    /**
+     * Check if the editor is edited.
+     * @returns {boolean}
+     */
+    isInEditMode(): boolean;
+    /**
+     * Check if this editor needs to be rebuilt or not.
+     * @returns {boolean}
+     */
+    needsToBeRebuilt(): boolean;
+    /**
+     * Rebuild the editor in case it has been removed on undo.
+     *
+     * To implement in subclasses.
+     */
+    rebuild(): void;
+    /**
+     * Rotate the editor.
+     * @param {number} angle
+     */
+    rotate(angle: any): void;
+    /**
+     * Serialize the editor.
+     * The result of the serialization will be used to construct a
+     * new annotation to add to the pdf document.
+     *
+     * To implement in subclasses.
+     * @param {boolean} [isForCopying]
+     * @param {Object | null} [context]
+     * @returns {Object | null}
+     */
+    serialize(isForCopying?: boolean, context?: any): void;
+    /**
+     * Deserialize the editor.
+     * The result of the deserialization is a new editor.
+     *
+     * @param {Object} data
+     * @param {AnnotationEditorLayer} parent
+     * @param {AnnotationEditorUIManager} uiManager
+     * @returns {AnnotationEditor | null}
+     */
+    static deserialize(data: any, parent: any, uiManager: any): any;
+    /**
+     * Check if an existing annotation associated with this editor has been
+     * modified.
+     * @returns {boolean}
+     */
+    get hasBeenModified(): boolean;
+    /**
+     * Remove this editor.
+     * It's used on ctrl+backspace action.
+     */
+    remove(): void;
+    /**
+     * @returns {boolean} true if this editor can be resized.
+     */
+    get isResizable(): boolean;
+    /**
+     * Add the resizers to this editor.
+     */
+    makeResizable(): void;
+    get toolbarPosition(): any;
+    _stopResizingWithKeyboard(): void;
+    /**
+     * Select this editor.
+     */
+    select(): void;
+    /**
+     * Unselect this editor.
+     */
+    unselect(): void;
+    /**
+     * Update some parameters which have been changed through the UI.
+     * @param {number} type
+     * @param {*} value
+     */
+    updateParams(type: any, value: any): void;
+    /**
+     * When the user disables the editing mode some editors can change some of
+     * their properties.
+     */
+    disableEditing(): void;
+    /**
+     * When the user enables the editing mode some editors can change some of
+     * their properties.
+     */
+    enableEditing(): void;
+    /**
+     * The editor is about to be edited.
+     */
+    enterInEditMode(): void;
+    /**
+     * @returns {HTMLElement | null} the element requiring an alt text.
+     */
+    getImageForAltText(): any;
+    /**
+     * Get the div which really contains the displayed content.
+     * @returns {HTMLDivElement | undefined}
+     */
+    get contentDiv(): any;
+    /**
+     * If true then the editor is currently edited.
+     * @type {boolean}
+     */
+    get isEditing(): boolean;
+    /**
+     * When set to true, it means that this editor is currently edited.
+     * @param {boolean} value
+     */
+    set isEditing(value: boolean);
+    /**
+     * Set the aspect ratio to use when resizing.
+     * @param {number} width
+     * @param {number} height
+     */
+    setAspectRatio(width: any, height: any): void;
+    static get MIN_SIZE(): number;
+    static canCreateNewEmptyEditor(): boolean;
+    /**
+     * Get the data to report to the telemetry when the editor is added.
+     * @returns {Object}
+     */
+    get telemetryInitialData(): {
+        action: string;
+    };
+    /**
+     * The telemetry data to use when saving/printing.
+     * @returns {Object|null}
+     */
+    get telemetryFinalData(): any;
+    _reportTelemetry(): void;
+    /**
+     * Show or hide this editor.
+     * @param {boolean|undefined} visible
+     */
+    show(visible?: boolean): void;
+    enable(): void;
+    disable(): void;
+    /**
+     * Render an annotation in the annotation layer.
+     * @param {Object} annotation
+     * @returns {HTMLElement}
+     */
+    renderAnnotationElement(annotation: any): any;
+    resetAnnotationElement(annotation: any): void;
+}