unpdf 1.6.2 → 1.8.0

package/dist/types/src/core/name_number_tree.d.ts

@@ -0,0 +1,21 @@
+export class NameTree extends NameOrNumberTree {
+    constructor(root: any, xref: any);
+}
+export class NumberTree extends NameOrNumberTree {
+    constructor(root: any, xref: any);
+}
+/**
+ * A NameTree/NumberTree is like a Dict but has some advantageous properties,
+ * see the specification (7.9.6 and 7.9.7) for additional details.
+ * TODO: implement all the Dict functions and make this more efficient.
+ */
+declare class NameOrNumberTree {
+    constructor(root: any, xref: any, type: any);
+    root: any;
+    xref: any;
+    _type: any;
+    getAll(isRaw?: boolean): Map<any, any>;
+    getRaw(key: any): any;
+    get(key: any): any;
+}
+export {};

package/dist/types/src/core/parser.d.ts

@@ -0,0 +1,121 @@
+export type Streams = Ascii85Stream | AsciiHexStream | BaseStream | BrotliStream | CCITTFaxStream | FlateStream | Jbig2Stream | JpegStream | JpxStream | LZWStream | NullStream | PredictorStream | RunLengthStream;
+export class Lexer {
+    constructor(stream: any, knownCommands?: null);
+    stream: any;
+    strBuf: any[];
+    knownCommands: any;
+    _hexStringNumWarn: number;
+    beginInlineImagePos: number;
+    nextChar(): any;
+    currentChar: any;
+    peekChar(): any;
+    getNumber(): number;
+    getString(): string;
+    getName(): any;
+    /**
+     * @private
+     */
+    private _hexStringWarn;
+    getHexString(): string;
+    getObj(): any;
+    skipToNextLine(): void;
+}
+export class Linearization {
+    static create(stream: any): {
+        length: any;
+        hints: any[];
+        objectNumberFirst: any;
+        endFirst: any;
+        numPages: any;
+        mainXRefEntriesOffset: any;
+        pageFirst: any;
+    } | null;
+}
+export class Parser {
+    constructor({ lexer, xref, allowStreams, recoveryMode }: {
+        lexer: any;
+        xref: any;
+        allowStreams?: boolean | undefined;
+        recoveryMode?: boolean | undefined;
+    });
+    lexer: any;
+    xref: any;
+    allowStreams: boolean;
+    recoveryMode: boolean;
+    imageCache: any;
+    _imageId: number;
+    refill(): void;
+    buf1: any;
+    buf2: any;
+    shift(): void;
+    tryShift(): boolean;
+    /**
+     * @param {CipherTransform | null} cipherTransform
+     *   Cipher transform for decryption.
+     * @returns {unknown}
+     */
+    getObj(cipherTransform?: CipherTransform | null): unknown;
+    /**
+     * Find the end of the stream by searching for the /EI\s/.
+     * @returns {number} The inline stream length.
+     */
+    findDefaultInlineStreamEnd(stream: any): number;
+    /**
+     * Find the EOI (end-of-image) marker 0xFFD9 of the stream.
+     * @returns {number} The inline stream length.
+     */
+    findDCTDecodeInlineStreamEnd(stream: any): number;
+    /**
+     * Find the EOD (end-of-data) marker '~>' (i.e. TILDE + GT) of the stream.
+     * @returns {number} The inline stream length.
+     */
+    findASCII85DecodeInlineStreamEnd(stream: any): number;
+    /**
+     * Find the EOD (end-of-data) marker '>' (i.e. GT) of the stream.
+     * @returns {number} The inline stream length.
+     */
+    findASCIIHexDecodeInlineStreamEnd(stream: any): number;
+    /**
+     * Skip over the /EI/ for streams where we search for an EOD marker.
+     */
+    inlineStreamSkipEI(stream: any): void;
+    /**
+     * @param {CipherTransform | null} cipherTransform
+     * @returns {Streams}
+     */
+    makeInlineImage(cipherTransform: CipherTransform | null): Streams;
+    makeStream(dict: any, cipherTransform: any): any;
+    /**
+     * @param {Streams} stream
+     * @param {Dict} dict
+     * @param {number | null} length
+     * @param {CipherTransform | null} cipherTransform
+     * @returns {Streams}
+     */
+    filter(stream: Streams, dict: Dict, length: number | null, cipherTransform?: CipherTransform | null): Streams;
+    /**
+     * @param {Streams} stream
+     * @param {string} name
+     * @param {number | null} maybeLength
+     * @param {Dict | null} params
+     * @param {CipherTransform | null | undefined} [cipherTransform]
+     * @returns {Streams}
+     */
+    makeFilter(stream: Streams, name: string, maybeLength: number | null, params: Dict | null, cipherTransform?: CipherTransform | null | undefined): Streams;
+    #private;
+}
+import { Ascii85Stream } from "./ascii_85_stream.js";
+import { AsciiHexStream } from "./ascii_hex_stream.js";
+import type { BaseStream } from "./base_stream.js";
+import { BrotliStream } from "./brotli_stream.js";
+import { CCITTFaxStream } from "./ccitt_stream.js";
+import { FlateStream } from "./flate_stream.js";
+import { Jbig2Stream } from "./jbig2_stream.js";
+import { JpegStream } from "./jpeg_stream.js";
+import { JpxStream } from "./jpx_stream.js";
+import { LZWStream } from "./lzw_stream.js";
+import { NullStream } from "./stream.js";
+import { PredictorStream } from "./predictor_stream.js";
+import { RunLengthStream } from "./run_length_stream.js";
+import type { CipherTransform } from "./crypto.js";
+import { Dict } from "./primitives.js";

package/dist/types/src/core/pattern.d.ts

@@ -0,0 +1,63 @@
+export function clearPatternCaches(): void;
+export function getTilingPatternIR(operatorList: any, dict: any, color: any, needsIsolation?: boolean): any[];
+export class Pattern {
+    static #hasGPU: boolean;
+    static setOptions({ hasGPU }: {
+        hasGPU: any;
+    }): void;
+    static parseShading(shading: any, xref: any, res: any, pdfFunctionFactory: any, globalColorSpaceCache: any, localColorSpaceCache: any): FunctionBasedShading | RadialAxialShading | MeshShading | DummyShading;
+}
+declare class FunctionBasedShading extends BaseShading {
+    static MAX_STEP_COUNT: number;
+    constructor(dict: any, xref: any, resources: any, pdfFunctionFactory: any, globalColorSpaceCache: any, localColorSpaceCache: any);
+    bbox: any;
+    background: any;
+    bounds: number[];
+    coords: Float32Array<ArrayBuffer>;
+    colors: Uint8ClampedArray<ArrayBuffer>;
+    figures: {
+        type: number;
+        coords: Uint32Array<ArrayBuffer>;
+        colors: Uint32Array<ArrayBuffer>;
+        verticesPerRow: number;
+    }[];
+    getIR(): any[];
+}
+declare class RadialAxialShading extends BaseShading {
+    constructor(dict: any, xref: any, resources: any, pdfFunctionFactory: any, globalColorSpaceCache: any, localColorSpaceCache: any);
+    shadingType: any;
+    coordsArr: any;
+    bbox: any;
+    extendStart: boolean;
+    extendEnd: boolean;
+    colorStops: any[];
+    getIR(): any[];
+}
+declare class MeshShading extends BaseShading {
+    static MIN_SPLIT_PATCH_CHUNKS_AMOUNT: number;
+    static MAX_SPLIT_PATCH_CHUNKS_AMOUNT: number;
+    static TRIANGLE_DENSITY: number;
+    constructor(stream: any, xref: any, resources: any, pdfFunctionFactory: any, globalColorSpaceCache: any, localColorSpaceCache: any);
+    shadingType: any;
+    bbox: any;
+    background: any;
+    coords: any[];
+    colors: any[];
+    figures: any[];
+    _decodeType4Shading(reader: any): void;
+    _decodeType5Shading(reader: any, verticesPerRow: any): void;
+    _decodeType6Shading(reader: any): void;
+    _decodeType7Shading(reader: any): void;
+    _buildFigureFromPatch(index: any): void;
+    _updateBounds(): void;
+    _packData(): void;
+    getIR(): any[];
+}
+declare class DummyShading extends BaseShading {
+    getIR(): string[];
+}
+declare class BaseShading {
+    static SMALL_NUMBER: number;
+    getIR(): void;
+}
+export {};

package/dist/types/src/core/predictor_stream.d.ts

@@ -0,0 +1,14 @@
+export class PredictorStream extends DecodeStream {
+    constructor(str: any, maybeLength: any, params: any);
+    predictor: any;
+    stream: any;
+    dict: any;
+    colors: any;
+    bits: any;
+    columns: any;
+    pixBytes: number | undefined;
+    rowBytes: number | undefined;
+    readBlockTiff(): void;
+    readBlockPng(): void;
+}
+import { DecodeStream } from "./decode_stream.js";

package/dist/types/src/core/primitives.d.ts

@@ -0,0 +1,81 @@
+export const CIRCULAR_REF: unique symbol;
+export function clearPrimitiveCaches(): void;
+export class Cmd {
+    static get(cmd: any): any;
+    constructor(cmd: any);
+    cmd: any;
+}
+export class Dict {
+    static get empty(): any;
+    static merge({ xref, dictArray, mergeSubDicts }: {
+        xref: any;
+        dictArray: any;
+        mergeSubDicts?: boolean | undefined;
+    }): any;
+    constructor(xref?: null);
+    __nonSerializable__: () => /*elided*/ any;
+    objId: null;
+    suppressEncryption: boolean;
+    xref: any;
+    assignXref(newXref: any): void;
+    get size(): number;
+    get(key1: any, key2: any, key3: any): any;
+    getAsync(key1: any, key2: any, key3: any): Promise<any>;
+    getArray(key1: any, key2: any, key3: any): any;
+    getRaw(key: any): any;
+    getKeys(): MapIterator<any>;
+    getRawValues(): MapIterator<any>;
+    getRawEntries(): MapIterator<[any, any]>;
+    set(key: any, value: any): void;
+    setIfNotExists(key: any, value: any): void;
+    setIfNumber(key: any, value: any): void;
+    setIfArray(key: any, value: any): void;
+    setIfDefined(key: any, value: any): void;
+    setIfName(key: any, value: any): void;
+    setIfDict(key: any, value: any): void;
+    has(key: any): boolean;
+    clone(): Dict;
+    delete(key: any): void;
+    [Symbol.iterator](): Generator<any[], void, unknown>;
+    #private;
+}
+export const EOF: unique symbol;
+export function isCmd(v: any, cmd: any): boolean;
+export function isDict(v: any, type: any): boolean;
+export function isName(v: any, name: any): boolean;
+export function isRefsEqual(v1: any, v2: any): boolean;
+export class Name {
+    static get(name: any): any;
+    constructor(name: any);
+    name: any;
+}
+export class Ref {
+    static fromString(str: any): any;
+    static get(num: any, gen: any): any;
+    constructor(num: any, gen: any);
+    num: any;
+    gen: any;
+    toString(): string;
+}
+export class RefSet {
+    constructor(parent?: null);
+    _set: Set<any>;
+    has(ref: any): boolean;
+    put(ref: any): void;
+    remove(ref: any): void;
+    clear(): void;
+    [Symbol.iterator](): SetIterator<any>;
+}
+export class RefSetCache {
+    _map: Map<any, any>;
+    get size(): number;
+    get(ref: any): any;
+    has(ref: any): boolean;
+    put(ref: any, obj: any): void;
+    putAlias(ref: any, aliasRef: any): void;
+    clear(): void;
+    values(): Generator<any, void, unknown>;
+    items(): Generator<any[], void, unknown>;
+    keys(): Generator<any, void, unknown>;
+    [Symbol.iterator](): MapIterator<any>;
+}

package/dist/types/src/core/run_length_stream.d.ts

@@ -0,0 +1,6 @@
+export class RunLengthStream extends DecodeStream {
+    constructor(str: any, maybeLength: any);
+    stream: any;
+    dict: any;
+}
+import { DecodeStream } from "./decode_stream.js";

package/dist/types/src/core/stream.d.ts

@@ -0,0 +1,20 @@
+export class NullStream extends Stream {
+    constructor();
+}
+export class Stream extends BaseStream {
+    constructor(arrayBuffer: any, start: any, length: any, dict: any);
+    bytes: Uint8Array<any>;
+    start: any;
+    pos: any;
+    end: any;
+    dict: any;
+    getByte(): number;
+    getBytes(length: any): Uint8Array<any>;
+    getByteRange(begin: any, end: any): Uint8Array<any>;
+    makeSubStream(start: any, length: any, dict?: null): Stream;
+    clone(): Stream;
+}
+export class StringStream extends Stream {
+    constructor(str: any, dict?: null);
+}
+import { BaseStream } from "./base_stream.js";

package/dist/types/src/core/string_utils.d.ts

@@ -0,0 +1,5 @@
+export function isAscii(str: any): boolean;
+export function stringToAsciiOrUTF16BE(str: any): any;
+export function stringToPDFString(str: any, keepEscapeSequence?: boolean): string;
+export function stringToUTF16HexString(str: any): string;
+export function stringToUTF16String(str: any, bigEndian?: boolean): string;

package/dist/types/src/core/struct_tree.d.ts

@@ -0,0 +1,93 @@
+export class StructTreePage {
+    constructor(structTreeRoot: any, pageDict: any);
+    root: any;
+    xref: any;
+    rootDict: any;
+    pageDict: any;
+    nodes: any[];
+    /**
+     * Collect all the objects (i.e. tag) that are part of the page and return a
+     * map of the structure element id to the object reference.
+     * @param {Ref} pageRef
+     * @returns {Map<number, Ref>}
+     */
+    collectObjects(pageRef: Ref): Map<number, Ref>;
+    parse(pageRef: any): void;
+    addNode(dict: any, map: any, level?: number): any;
+    addTopLevelNode(dict: any, element: any): boolean;
+    /**
+     * Convert the tree structure into a simplified object literal that can
+     * be sent to the main thread.
+     * @returns {Object}
+     */
+    get serializable(): Object;
+}
+export class StructTreeRoot {
+    static canCreateStructureTree({ catalogRef, pdfManager, newAnnotationsByPage, }: {
+        catalogRef: any;
+        pdfManager: any;
+        newAnnotationsByPage: any;
+    }): Promise<boolean>;
+    static createStructureTree({ newAnnotationsByPage, xref, catalogRef, pdfManager, changes, }: {
+        newAnnotationsByPage: any;
+        xref: any;
+        catalogRef: any;
+        pdfManager: any;
+        changes: any;
+    }): Promise<void>;
+    static #writeKids({ newAnnotationsByPage, structTreeRootRef, structTreeRoot, kids, nums, xref, pdfManager, changes, cache, }: {
+        newAnnotationsByPage: any;
+        structTreeRootRef: any;
+        structTreeRoot: any;
+        kids: any;
+        nums: any;
+        xref: any;
+        pdfManager: any;
+        changes: any;
+        cache: any;
+    }): Promise<number>;
+    static #writeProperties(tagDict: any, { type, title, lang, alt, expanded, actualText }: {
+        type: any;
+        title: any;
+        lang: any;
+        alt: any;
+        expanded: any;
+        actualText: any;
+    }): void;
+    static #collectParents({ elements, xref, pageDict, numberTree }: {
+        elements: any;
+        xref: any;
+        pageDict: any;
+        numberTree: any;
+    }): void;
+    static #updateParentTag({ structTreeParent, tagDict, newTagRef, structTreeRootRef, fallbackKids, xref, cache, }: {
+        structTreeParent: any;
+        tagDict: any;
+        newTagRef: any;
+        structTreeRootRef: any;
+        fallbackKids: any;
+        xref: any;
+        cache: any;
+    }): Promise<void>;
+    constructor(xref: any, rootDict: any, rootRef: any);
+    kidRefToPosition: undefined;
+    parentTree: null;
+    roleMap: Map<any, any>;
+    structParentIds: null;
+    xref: any;
+    dict: any;
+    ref: Ref | null;
+    getKidPosition(kidRef: any): any;
+    addAnnotationIdToPage(pageRef: any, id: any): void;
+    canUpdateStructTree({ pdfManager, newAnnotationsByPage }: {
+        pdfManager: any;
+        newAnnotationsByPage: any;
+    }): Promise<boolean>;
+    updateStructureTree({ newAnnotationsByPage, pdfManager, changes }: {
+        newAnnotationsByPage: any;
+        pdfManager: any;
+        changes: any;
+    }): Promise<void>;
+    #private;
+}
+import { Ref } from "./primitives.js";

package/dist/types/src/core/unicode.d.ts

@@ -0,0 +1,5 @@
+export function clearUnicodeCaches(): void;
+export function getCharUnicodeCategory(char: any): any;
+export function getUnicodeForGlyph(name: any, glyphsUnicodeMap: any): any;
+export function getUnicodeRangeFor(value: any, lastPosition?: number): number;
+export function mapSpecialUnicodeValues(code: any): any;

package/dist/types/src/core/wasm_image.d.ts

@@ -0,0 +1,21 @@
+export class WasmImage {
+    static #handler: null;
+    static #instances: Set<any>;
+    static #useWasm: boolean;
+    static #useWorkerFetch: boolean;
+    static #wasmUrl: null;
+    static setOptions({ handler, useWasm, useWorkerFetch, wasmUrl }: {
+        handler: any;
+        useWasm: any;
+        useWorkerFetch: any;
+        wasmUrl: any;
+    }): void;
+    static get instance(): void;
+    static cleanup(): void;
+    constructor(trackInstance?: boolean);
+    _filename: null;
+    _noWasmFilename: null;
+    _getModule(ImageDecoder: any): null;
+    decode(bytes: any, _params: any): Promise<void>;
+    #private;
+}

package/dist/types/src/core/xml_parser.d.ts

@@ -0,0 +1,79 @@
+export class SimpleDOMNode {
+    constructor(nodeName: any, nodeValue: any);
+    nodeName: any;
+    nodeValue: any;
+    get firstChild(): any;
+    get nextSibling(): any;
+    get textContent(): any;
+    get children(): any;
+    hasChildNodes(): boolean;
+    /**
+     * Search a node in the tree with the given path
+     * foo.bar[nnn], i.e. find the nnn-th node named
+     * bar under a node named foo.
+     *
+     * @param {Array} paths - an array of objects as
+     * returned by {parseXFAPath}.
+     * @param {number} pos - the current position in
+     * the paths array.
+     * @returns {SimpleDOMNode} The node corresponding
+     * to the path or null if not found.
+     */
+    searchNode(paths: any[], pos: number): SimpleDOMNode;
+    dump(buffer: any): void;
+}
+export class SimpleXMLParser extends XMLParserBase {
+    constructor({ hasAttributes, lowerCaseName }: {
+        hasAttributes?: boolean | undefined;
+        lowerCaseName?: boolean | undefined;
+    });
+    _currentFragment: any;
+    _stack: any[] | null;
+    _errorCode: number;
+    _hasAttributes: boolean;
+    _lowerCaseName: boolean;
+    parseFromString(data: any): {
+        documentElement: any;
+    } | undefined;
+    onEndElement(name: any): any;
+}
+export class XMLParserBase {
+    static get _entityRegex(): any;
+    _resolveEntities(s: any): any;
+    _parseContent(s: any, start: any): {
+        name: any;
+        attributes: {
+            name: string;
+            value: any;
+        }[];
+        parsed: number;
+    } | null;
+    _parseProcessingInstruction(s: any, start: any): {
+        name: any;
+        value: any;
+        parsed: number;
+    };
+    parseXml(s: any): void;
+    onResolveEntity(name: any): string;
+    onPi(name: any, value: any): void;
+    onComment(text: any): void;
+    onCdata(text: any): void;
+    onDoctype(doctypeContent: any): void;
+    onText(text: any): void;
+    onBeginElement(name: any, attributes: any, isEmpty: any): void;
+    onEndElement(name: any): void;
+    onError(code: any): void;
+}
+export namespace XMLParserErrorCode {
+    let NoError: number;
+    let EndOfDocument: number;
+    let UnterminatedCdat: number;
+    let UnterminatedXmlDeclaration: number;
+    let UnterminatedDoctypeDeclaration: number;
+    let UnterminatedComment: number;
+    let MalformedElement: number;
+    let OutOfMemory: number;
+    let UnterminatedAttributeValue: number;
+    let UnterminatedElement: number;
+    let ElementNeverBegun: number;
+}

package/dist/types/src/core/xref.d.ts

@@ -0,0 +1,52 @@
+export class XRef {
+    constructor(stream: any, pdfManager: any);
+    stream: any;
+    pdfManager: any;
+    entries: any[];
+    _xrefStms: Set<any>;
+    _cacheMap: Map<any, any>;
+    _pendingRefs: RefSet;
+    _newPersistentRefNum: number | null;
+    _newTemporaryRefNum: number | null;
+    _persistentRefsCache: Map<any, any> | null;
+    getNewPersistentRef(obj: any): any;
+    getNewTemporaryRef(): any;
+    resetNewTemporaryRef(): void;
+    setStartXRef(startXRef: any): void;
+    startXRefQueue: any[] | undefined;
+    parse(recoveryMode?: boolean): void;
+    trailer: any;
+    encrypt: CipherTransformFactory | undefined;
+    root: Dict | undefined;
+    processXRefTable(parser: any): Dict;
+    tableState: {
+        entryNum: number;
+        streamPos: any;
+        parserBuf1: any;
+        parserBuf2: any;
+    } | undefined;
+    readXRefTable(parser: any): any;
+    processXRefStream(stream: any): any;
+    streamState: {
+        entryRanges: any;
+        byteWidths: any;
+        entryNum: number;
+        streamPos: any;
+    } | undefined;
+    readXRefStream(stream: any): void;
+    indexObjects(): any;
+    _generationFallback: boolean | undefined;
+    readXRef(recoveryMode?: boolean): any;
+    topDict: any;
+    getEntry(i: any): any;
+    fetchIfRef(obj: any, suppressEncryption?: boolean): any;
+    fetch(ref: any, suppressEncryption?: boolean): any;
+    fetchUncompressed(ref: any, xrefEntry: any, suppressEncryption?: boolean): any;
+    fetchCompressed(ref: any, xrefEntry: any, suppressEncryption?: boolean): any;
+    fetchIfRefAsync(obj: any, suppressEncryption: any): Promise<any>;
+    fetchAsync(ref: any, suppressEncryption: any): any;
+    getCatalogObj(): Dict | undefined;
+}
+import { RefSet } from "./primitives.js";
+import { CipherTransformFactory } from "./crypto.js";
+import { Dict } from "./primitives.js";

package/dist/types/src/display/annotation_layer.d.ts

@@ -1,5 +1,6 @@
-export type PDFPageProxy = import("./api").PDFPageProxy;
-export type PageViewport = import("./display_utils").PageViewport;
+export type PDFPageProxy = import("./api.js").PDFPageProxy;
+export type PageViewport = import("./page_viewport.js").PageViewport;
+export type OptionalContentConfig = any;
 export type TextAccessibilityManager = import("../../web/text_accessibility.js").TextAccessibilityManager;
 export type AnnotationEditorUIManager = any;
 export type StructTreeLayerBuilder = import("../../web/struct_tree_layer_builder.js").StructTreeLayerBuilder;
@@ -53,10 +54,7 @@ export type AnnotationLayerParameters = {
     accessibilityManager?: import("../../web/text_accessibility.js").TextAccessibilityManager | undefined;
     annotationEditorUIManager?: AnnotationEditorUIManager;
     structTreeLayer?: import("../../web/struct_tree_layer_builder.js").StructTreeLayerBuilder | undefined;
-    /**
-     * - The comment manager instance.
-     */
-    commentManager?: import("../../web/comment_manager.js").CommentManager | undefined;
+    optionalContentConfig?: OptionalContentConfig;
 };
 /**
  * @typedef {Object} AnnotationLayerParameters
@@ -78,7 +76,7 @@ export type AnnotationLayerParameters = {
  * @property {TextAccessibilityManager} [accessibilityManager]
  * @property {AnnotationEditorUIManager} [annotationEditorUIManager]
  * @property {StructTreeLayerBuilder} [structTreeLayer]
- * @property {CommentManager} [commentManager] - The comment manager instance.
+ * @property {OptionalContentConfig} [optionalContentConfig]
  */
 /**
  * Manage the layer containing all the annotations.
@@ -100,10 +98,10 @@ export class AnnotationLayer {
         linkService: any;
         annotationStorage: any;
     });
+    zIndex: number;
     div: any;
     page: any;
     viewport: any;
-    zIndex: number;
     _annotationEditorUIManager: any;
     _commentManager: any;
     popupShow: any[] | undefined;
@@ -127,7 +125,9 @@ export class AnnotationLayer {
      * @param {AnnotationLayerParameters} viewport
      * @memberof AnnotationLayer
      */
-    update({ viewport }: AnnotationLayerParameters): void;
+    update({ viewport, optionalContentConfig }: AnnotationLayerParameters): void;
+    destroy(): void;
+    refreshCanvases(): void;
     getEditableAnnotations(): MapIterator<any>;
     getEditableAnnotation(id: any): any;
     addFakeAnnotation(editor: any): EditorAnnotationElement;
@@ -267,8 +267,10 @@ declare class AnnotationElement {
     public getElementsToTriggerPopup(): Array<HTMLElement> | HTMLElement;
     addHighlightArea(): void;
     _editOnDoubleClick(): void;
+    updateOC(optionalContentConfig: any): void;
     get width(): number;
     get height(): number;
+    _setBackgroundColor(element: any): void;
     #private;
 }
 export {};