@payloadcms/richtext-lexical 3.2.3-canary.2d2e7d5 → 3.2.3-canary.673b4b5

package/dist/features/blocks/WrapperBlockNode.d.ts

@@ -0,0 +1,1151 @@
+import type { BaseSelection, DOMConversionMap, DOMExportOutput, EditorConfig, ElementNode as ElementNodeType, LexicalEditor, LexicalNode, NodeKey, RangeSelection, SerializedElementNode, SerializedLexicalNode, Spread } from 'lexical';
+import type { JsonObject } from 'payload';
+import { ElementNode } from 'lexical';
+export type WrapperBlockFields<TWrapperBlockFields extends JsonObject = JsonObject> = {
+    /** Block form data */
+    [key: string]: any;
+    blockType: string;
+    id: string;
+} & TWrapperBlockFields;
+export type SerializedWrapperBlockNode<T extends SerializedLexicalNode = SerializedLexicalNode, TBlockFields extends JsonObject = JsonObject> = Spread<{
+    fields: WrapperBlockFields<TBlockFields>;
+    type: 'wrapperBlock';
+}, SerializedElementNode<T>>;
+export type CreateDOMFunction = (args: {
+    editor: LexicalEditor;
+    editorConfig: EditorConfig;
+    node: WrapperBlockNodeType;
+}) => HTMLElement;
+export type DOMMap = {
+    [blockType: string]: CreateDOMFunction;
+};
+export declare function getWrapperBlockNode(domMap: DOMMap): {
+    $createWrapperBlockNode: (fields: WrapperBlockFields) => {
+        __fields: WrapperBlockFields;
+        canBeEmpty(): false;
+        canInsertTextAfter(): false;
+        canInsertTextBefore(): false;
+        createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
+        exportDOM(): DOMExportOutput;
+        exportJSON(): SerializedWrapperBlockNode;
+        extractWithChild(child: LexicalNode, selection: BaseSelection, destination: "clone" | "html"): boolean;
+        getFields(): WrapperBlockFields;
+        insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): ElementNodeType | null;
+        isInline(): true;
+        setFields(fields: WrapperBlockFields): void;
+        updateDOM(prevNode: /*elided*/ any, anchor: HTMLAnchorElement, config: EditorConfig): boolean;
+        getTopLevelElement(): ElementNode | null;
+        getTopLevelElementOrThrow(): ElementNode;
+        constructor: import("lexical").KlassConstructor<typeof ElementNode>;
+        __first: null | NodeKey;
+        __last: null | NodeKey;
+        __size: number;
+        __format: number;
+        __style: string;
+        __indent: number;
+        __dir: "ltr" | "rtl" | null;
+        afterCloneFrom(prevNode: /*elided*/ any): void;
+        getFormat(): number;
+        getFormatType(): import("lexical").ElementFormatType;
+        getStyle(): string;
+        getIndent(): number;
+        getChildren<T extends LexicalNode>(): Array<T>;
+        getChildrenKeys(): Array<NodeKey>;
+        getChildrenSize(): number;
+        isEmpty(): boolean;
+        isDirty(): boolean;
+        isLastChild(): boolean;
+        getAllTextNodes(): Array<import("lexical").TextNode>;
+        getFirstDescendant<T extends LexicalNode>(): T | null;
+        getLastDescendant<T extends LexicalNode>(): T | null;
+        getDescendantByIndex<T extends LexicalNode>(index: number): T | null;
+        getFirstChild<T extends LexicalNode>(): T | null;
+        getFirstChildOrThrow<T extends LexicalNode>(): T;
+        getLastChild<T extends LexicalNode>(): T | null;
+        getLastChildOrThrow<T extends LexicalNode>(): T;
+        getChildAtIndex<T extends LexicalNode>(index: number): T | null;
+        getTextContent(): string;
+        getTextContentSize(): number;
+        getDirection(): "ltr" | "rtl" | null;
+        hasFormat(type: import("lexical").ElementFormatType): boolean;
+        select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+        selectStart(): RangeSelection;
+        selectEnd(): RangeSelection;
+        clear(): /*elided*/ any;
+        append(...nodesToAppend: LexicalNode[]): /*elided*/ any;
+        setDirection(direction: "ltr" | "rtl" | null): /*elided*/ any;
+        setFormat(type: import("lexical").ElementFormatType): /*elided*/ any;
+        setStyle(style: string): /*elided*/ any;
+        setIndent(indentLevel: number): /*elided*/ any;
+        splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): /*elided*/ any;
+        canIndent(): boolean;
+        collapseAtStart(selection: RangeSelection): boolean;
+        excludeFromCopy(destination?: "clone" | "html"): boolean;
+        canReplaceWith(replacement: LexicalNode): boolean;
+        canInsertAfter(node: LexicalNode): boolean;
+        isShadowRoot(): boolean;
+        canMergeWith(node: ElementNode): boolean;
+        canMergeWhenEmpty(): boolean;
+        __type: string;
+        __key: string;
+        __parent: null | NodeKey;
+        __prev: null | NodeKey;
+        __next: null | NodeKey;
+        getType(): string;
+        isAttached(): boolean;
+        isSelected(selection?: null | BaseSelection): boolean;
+        getKey(): NodeKey;
+        getIndexWithinParent(): number;
+        getParent<T extends ElementNode>(): T | null;
+        getParentOrThrow<T extends ElementNode>(): T;
+        getParents(): Array<ElementNode>;
+        getParentKeys(): Array<NodeKey>;
+        getPreviousSibling<T extends LexicalNode>(): T | null;
+        getPreviousSiblings<T extends LexicalNode>(): Array<T>;
+        getNextSibling<T extends LexicalNode>(): T | null;
+        getNextSiblings<T extends LexicalNode>(): Array<T>;
+        getCommonAncestor<T extends ElementNode = ElementNodeType>(node: LexicalNode): T | null;
+        is(object: LexicalNode | null | undefined): boolean;
+        isBefore(targetNode: LexicalNode): boolean;
+        isParentOf(targetNode: LexicalNode): boolean;
+        getNodesBetween(targetNode: LexicalNode): Array<LexicalNode>;
+        getLatest(): /*elided*/ any;
+        getWritable(): /*elided*/ any;
+        remove(preserveEmptyParent?: boolean): void;
+        replace<N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N;
+        insertAfter(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+        insertBefore(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+        isParentRequired(): boolean;
+        createParentElementNode(): ElementNode;
+        selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+        selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
+        markDirty(): void;
+    };
+    $isWrapperBlockNode: (node: LexicalNode | null | {
+        new ({ fields, key }: {
+            fields: WrapperBlockFields;
+            key?: NodeKey;
+        }): {
+            __fields: WrapperBlockFields;
+            canBeEmpty(): false;
+            canInsertTextAfter(): false;
+            canInsertTextBefore(): false;
+            createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
+            exportDOM(): DOMExportOutput;
+            exportJSON(): SerializedWrapperBlockNode;
+            extractWithChild(child: LexicalNode, selection: BaseSelection, destination: "clone" | "html"): boolean;
+            getFields(): WrapperBlockFields;
+            insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): ElementNodeType | null;
+            isInline(): true;
+            setFields(fields: WrapperBlockFields): void;
+            updateDOM(prevNode: /*elided*/ any, anchor: HTMLAnchorElement, config: EditorConfig): boolean;
+            getTopLevelElement(): ElementNode | null;
+            getTopLevelElementOrThrow(): ElementNode;
+            constructor: import("lexical").KlassConstructor<typeof ElementNode>;
+            __first: null | NodeKey;
+            __last: null | NodeKey;
+            __size: number;
+            __format: number;
+            __style: string;
+            __indent: number;
+            __dir: "ltr" | "rtl" | null;
+            afterCloneFrom(prevNode: /*elided*/ any): void;
+            getFormat(): number;
+            getFormatType(): import("lexical").ElementFormatType;
+            getStyle(): string;
+            getIndent(): number;
+            getChildren<T extends LexicalNode>(): Array<T>;
+            getChildrenKeys(): Array<NodeKey>;
+            getChildrenSize(): number;
+            isEmpty(): boolean;
+            isDirty(): boolean;
+            isLastChild(): boolean;
+            getAllTextNodes(): Array<import("lexical").TextNode>;
+            getFirstDescendant<T extends LexicalNode>(): T | null;
+            getLastDescendant<T extends LexicalNode>(): T | null;
+            getDescendantByIndex<T extends LexicalNode>(index: number): T | null;
+            getFirstChild<T extends LexicalNode>(): T | null;
+            getFirstChildOrThrow<T extends LexicalNode>(): T;
+            getLastChild<T extends LexicalNode>(): T | null;
+            getLastChildOrThrow<T extends LexicalNode>(): T;
+            getChildAtIndex<T extends LexicalNode>(index: number): T | null;
+            getTextContent(): string;
+            getTextContentSize(): number;
+            getDirection(): "ltr" | "rtl" | null;
+            hasFormat(type: import("lexical").ElementFormatType): boolean;
+            select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+            selectStart(): RangeSelection;
+            selectEnd(): RangeSelection;
+            clear(): /*elided*/ any;
+            append(...nodesToAppend: LexicalNode[]): /*elided*/ any;
+            setDirection(direction: "ltr" | "rtl" | null): /*elided*/ any;
+            setFormat(type: import("lexical").ElementFormatType): /*elided*/ any;
+            setStyle(style: string): /*elided*/ any;
+            setIndent(indentLevel: number): /*elided*/ any;
+            splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): /*elided*/ any;
+            canIndent(): boolean;
+            collapseAtStart(selection: RangeSelection): boolean;
+            excludeFromCopy(destination?: "clone" | "html"): boolean;
+            canReplaceWith(replacement: LexicalNode): boolean;
+            canInsertAfter(node: LexicalNode): boolean;
+            isShadowRoot(): boolean;
+            canMergeWith(node: ElementNode): boolean;
+            canMergeWhenEmpty(): boolean;
+            __type: string;
+            __key: string;
+            __parent: null | NodeKey;
+            __prev: null | NodeKey;
+            __next: null | NodeKey;
+            getType(): string;
+            isAttached(): boolean;
+            isSelected(selection?: null | BaseSelection): boolean;
+            getKey(): NodeKey;
+            getIndexWithinParent(): number;
+            getParent<T extends ElementNode>(): T | null;
+            getParentOrThrow<T extends ElementNode>(): T;
+            getParents(): Array<ElementNode>;
+            getParentKeys(): Array<NodeKey>;
+            getPreviousSibling<T extends LexicalNode>(): T | null;
+            getPreviousSiblings<T extends LexicalNode>(): Array<T>;
+            getNextSibling<T extends LexicalNode>(): T | null;
+            getNextSiblings<T extends LexicalNode>(): Array<T>;
+            getCommonAncestor<T extends ElementNode = ElementNodeType>(node: LexicalNode): T | null;
+            is(object: LexicalNode | null | undefined): boolean;
+            isBefore(targetNode: LexicalNode): boolean;
+            isParentOf(targetNode: LexicalNode): boolean;
+            getNodesBetween(targetNode: LexicalNode): Array<LexicalNode>;
+            getLatest(): /*elided*/ any;
+            getWritable(): /*elided*/ any;
+            remove(preserveEmptyParent?: boolean): void;
+            replace<N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N;
+            insertAfter(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            insertBefore(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            isParentRequired(): boolean;
+            createParentElementNode(): ElementNode;
+            selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            markDirty(): void;
+        };
+        clone(node: {
+            __fields: WrapperBlockFields;
+            canBeEmpty(): false;
+            canInsertTextAfter(): false;
+            canInsertTextBefore(): false;
+            createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
+            exportDOM(): DOMExportOutput;
+            exportJSON(): SerializedWrapperBlockNode;
+            extractWithChild(child: LexicalNode, selection: BaseSelection, destination: "clone" | "html"): boolean;
+            getFields(): WrapperBlockFields;
+            insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): ElementNodeType | null;
+            isInline(): true;
+            setFields(fields: WrapperBlockFields): void;
+            updateDOM(prevNode: /*elided*/ any, anchor: HTMLAnchorElement, config: EditorConfig): boolean;
+            getTopLevelElement(): ElementNode | null;
+            getTopLevelElementOrThrow(): ElementNode;
+            constructor: import("lexical").KlassConstructor<typeof ElementNode>;
+            __first: null | NodeKey;
+            __last: null | NodeKey;
+            __size: number;
+            __format: number;
+            __style: string;
+            __indent: number;
+            __dir: "ltr" | "rtl" | null;
+            afterCloneFrom(prevNode: /*elided*/ any): void;
+            getFormat(): number;
+            getFormatType(): import("lexical").ElementFormatType;
+            getStyle(): string;
+            getIndent(): number;
+            getChildren<T extends LexicalNode>(): Array<T>;
+            getChildrenKeys(): Array<NodeKey>;
+            getChildrenSize(): number;
+            isEmpty(): boolean;
+            isDirty(): boolean;
+            isLastChild(): boolean;
+            getAllTextNodes(): Array<import("lexical").TextNode>;
+            getFirstDescendant<T extends LexicalNode>(): T | null;
+            getLastDescendant<T extends LexicalNode>(): T | null;
+            getDescendantByIndex<T extends LexicalNode>(index: number): T | null;
+            getFirstChild<T extends LexicalNode>(): T | null;
+            getFirstChildOrThrow<T extends LexicalNode>(): T;
+            getLastChild<T extends LexicalNode>(): T | null;
+            getLastChildOrThrow<T extends LexicalNode>(): T;
+            getChildAtIndex<T extends LexicalNode>(index: number): T | null;
+            getTextContent(): string;
+            getTextContentSize(): number;
+            getDirection(): "ltr" | "rtl" | null;
+            hasFormat(type: import("lexical").ElementFormatType): boolean;
+            select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+            selectStart(): RangeSelection;
+            selectEnd(): RangeSelection;
+            clear(): /*elided*/ any;
+            append(...nodesToAppend: LexicalNode[]): /*elided*/ any;
+            setDirection(direction: "ltr" | "rtl" | null): /*elided*/ any;
+            setFormat(type: import("lexical").ElementFormatType): /*elided*/ any;
+            setStyle(style: string): /*elided*/ any;
+            setIndent(indentLevel: number): /*elided*/ any;
+            splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): /*elided*/ any;
+            canIndent(): boolean;
+            collapseAtStart(selection: RangeSelection): boolean;
+            excludeFromCopy(destination?: "clone" | "html"): boolean;
+            canReplaceWith(replacement: LexicalNode): boolean;
+            canInsertAfter(node: LexicalNode): boolean;
+            isShadowRoot(): boolean;
+            canMergeWith(node: ElementNode): boolean;
+            canMergeWhenEmpty(): boolean;
+            __type: string;
+            __key: string;
+            __parent: null | NodeKey;
+            __prev: null | NodeKey;
+            __next: null | NodeKey;
+            getType(): string;
+            isAttached(): boolean;
+            isSelected(selection?: null | BaseSelection): boolean;
+            getKey(): NodeKey;
+            getIndexWithinParent(): number;
+            getParent<T extends ElementNode>(): T | null;
+            getParentOrThrow<T extends ElementNode>(): T;
+            getParents(): Array<ElementNode>;
+            getParentKeys(): Array<NodeKey>;
+            getPreviousSibling<T extends LexicalNode>(): T | null;
+            getPreviousSiblings<T extends LexicalNode>(): Array<T>;
+            getNextSibling<T extends LexicalNode>(): T | null;
+            getNextSiblings<T extends LexicalNode>(): Array<T>;
+            getCommonAncestor<T extends ElementNode = ElementNodeType>(node: LexicalNode): T | null;
+            is(object: LexicalNode | null | undefined): boolean;
+            isBefore(targetNode: LexicalNode): boolean;
+            isParentOf(targetNode: LexicalNode): boolean;
+            getNodesBetween(targetNode: LexicalNode): Array<LexicalNode>;
+            getLatest(): /*elided*/ any;
+            getWritable(): /*elided*/ any;
+            remove(preserveEmptyParent?: boolean): void;
+            replace<N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N;
+            insertAfter(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            insertBefore(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            isParentRequired(): boolean;
+            createParentElementNode(): ElementNode;
+            selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            markDirty(): void;
+        }): {
+            __fields: WrapperBlockFields;
+            canBeEmpty(): false;
+            canInsertTextAfter(): false;
+            canInsertTextBefore(): false;
+            createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
+            exportDOM(): DOMExportOutput;
+            exportJSON(): SerializedWrapperBlockNode;
+            extractWithChild(child: LexicalNode, selection: BaseSelection, destination: "clone" | "html"): boolean;
+            getFields(): WrapperBlockFields;
+            insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): ElementNodeType | null;
+            isInline(): true;
+            setFields(fields: WrapperBlockFields): void;
+            updateDOM(prevNode: /*elided*/ any, anchor: HTMLAnchorElement, config: EditorConfig): boolean;
+            getTopLevelElement(): ElementNode | null;
+            getTopLevelElementOrThrow(): ElementNode;
+            constructor: import("lexical").KlassConstructor<typeof ElementNode>;
+            __first: null | NodeKey;
+            __last: null | NodeKey;
+            __size: number;
+            __format: number;
+            __style: string;
+            __indent: number;
+            __dir: "ltr" | "rtl" | null;
+            afterCloneFrom(prevNode: /*elided*/ any): void;
+            getFormat(): number;
+            getFormatType(): import("lexical").ElementFormatType;
+            getStyle(): string;
+            getIndent(): number;
+            getChildren<T extends LexicalNode>(): Array<T>;
+            getChildrenKeys(): Array<NodeKey>;
+            getChildrenSize(): number;
+            isEmpty(): boolean;
+            isDirty(): boolean;
+            isLastChild(): boolean;
+            getAllTextNodes(): Array<import("lexical").TextNode>;
+            getFirstDescendant<T extends LexicalNode>(): T | null;
+            getLastDescendant<T extends LexicalNode>(): T | null;
+            getDescendantByIndex<T extends LexicalNode>(index: number): T | null;
+            getFirstChild<T extends LexicalNode>(): T | null;
+            getFirstChildOrThrow<T extends LexicalNode>(): T;
+            getLastChild<T extends LexicalNode>(): T | null;
+            getLastChildOrThrow<T extends LexicalNode>(): T;
+            getChildAtIndex<T extends LexicalNode>(index: number): T | null;
+            getTextContent(): string;
+            getTextContentSize(): number;
+            getDirection(): "ltr" | "rtl" | null;
+            hasFormat(type: import("lexical").ElementFormatType): boolean;
+            select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+            selectStart(): RangeSelection;
+            selectEnd(): RangeSelection;
+            clear(): /*elided*/ any;
+            append(...nodesToAppend: LexicalNode[]): /*elided*/ any;
+            setDirection(direction: "ltr" | "rtl" | null): /*elided*/ any;
+            setFormat(type: import("lexical").ElementFormatType): /*elided*/ any;
+            setStyle(style: string): /*elided*/ any;
+            setIndent(indentLevel: number): /*elided*/ any;
+            splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): /*elided*/ any;
+            canIndent(): boolean;
+            collapseAtStart(selection: RangeSelection): boolean;
+            excludeFromCopy(destination?: "clone" | "html"): boolean;
+            canReplaceWith(replacement: LexicalNode): boolean;
+            canInsertAfter(node: LexicalNode): boolean;
+            isShadowRoot(): boolean;
+            canMergeWith(node: ElementNode): boolean;
+            canMergeWhenEmpty(): boolean;
+            __type: string;
+            __key: string;
+            __parent: null | NodeKey;
+            __prev: null | NodeKey;
+            __next: null | NodeKey;
+            getType(): string;
+            isAttached(): boolean;
+            isSelected(selection?: null | BaseSelection): boolean;
+            getKey(): NodeKey;
+            getIndexWithinParent(): number;
+            getParent<T extends ElementNode>(): T | null;
+            getParentOrThrow<T extends ElementNode>(): T;
+            getParents(): Array<ElementNode>;
+            getParentKeys(): Array<NodeKey>;
+            getPreviousSibling<T extends LexicalNode>(): T | null;
+            getPreviousSiblings<T extends LexicalNode>(): Array<T>;
+            getNextSibling<T extends LexicalNode>(): T | null;
+            getNextSiblings<T extends LexicalNode>(): Array<T>;
+            getCommonAncestor<T extends ElementNode = ElementNodeType>(node: LexicalNode): T | null;
+            is(object: LexicalNode | null | undefined): boolean;
+            isBefore(targetNode: LexicalNode): boolean;
+            isParentOf(targetNode: LexicalNode): boolean;
+            getNodesBetween(targetNode: LexicalNode): Array<LexicalNode>;
+            getLatest(): /*elided*/ any;
+            getWritable(): /*elided*/ any;
+            remove(preserveEmptyParent?: boolean): void;
+            replace<N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N;
+            insertAfter(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            insertBefore(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            isParentRequired(): boolean;
+            createParentElementNode(): ElementNode;
+            selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            markDirty(): void;
+        };
+        getType(): string;
+        importDOM(): DOMConversionMap<HTMLDivElement> | null;
+        importJSON(serializedNode: SerializedWrapperBlockNode): {
+            __fields: WrapperBlockFields;
+            canBeEmpty(): false;
+            canInsertTextAfter(): false;
+            canInsertTextBefore(): false;
+            createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
+            exportDOM(): DOMExportOutput;
+            exportJSON(): SerializedWrapperBlockNode;
+            extractWithChild(child: LexicalNode, selection: BaseSelection, destination: "clone" | "html"): boolean;
+            getFields(): WrapperBlockFields;
+            insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): ElementNodeType | null;
+            isInline(): true;
+            setFields(fields: WrapperBlockFields): void;
+            updateDOM(prevNode: /*elided*/ any, anchor: HTMLAnchorElement, config: EditorConfig): boolean;
+            getTopLevelElement(): ElementNode | null;
+            getTopLevelElementOrThrow(): ElementNode;
+            constructor: import("lexical").KlassConstructor<typeof ElementNode>;
+            __first: null | NodeKey;
+            __last: null | NodeKey;
+            __size: number;
+            __format: number;
+            __style: string;
+            __indent: number;
+            __dir: "ltr" | "rtl" | null;
+            afterCloneFrom(prevNode: /*elided*/ any): void;
+            getFormat(): number;
+            getFormatType(): import("lexical").ElementFormatType;
+            getStyle(): string;
+            getIndent(): number;
+            getChildren<T extends LexicalNode>(): Array<T>;
+            getChildrenKeys(): Array<NodeKey>;
+            getChildrenSize(): number;
+            isEmpty(): boolean;
+            isDirty(): boolean;
+            isLastChild(): boolean;
+            getAllTextNodes(): Array<import("lexical").TextNode>;
+            getFirstDescendant<T extends LexicalNode>(): T | null;
+            getLastDescendant<T extends LexicalNode>(): T | null;
+            getDescendantByIndex<T extends LexicalNode>(index: number): T | null;
+            getFirstChild<T extends LexicalNode>(): T | null;
+            getFirstChildOrThrow<T extends LexicalNode>(): T;
+            getLastChild<T extends LexicalNode>(): T | null;
+            getLastChildOrThrow<T extends LexicalNode>(): T;
+            getChildAtIndex<T extends LexicalNode>(index: number): T | null;
+            getTextContent(): string;
+            getTextContentSize(): number;
+            getDirection(): "ltr" | "rtl" | null;
+            hasFormat(type: import("lexical").ElementFormatType): boolean;
+            select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+            selectStart(): RangeSelection;
+            selectEnd(): RangeSelection;
+            clear(): /*elided*/ any;
+            append(...nodesToAppend: LexicalNode[]): /*elided*/ any;
+            setDirection(direction: "ltr" | "rtl" | null): /*elided*/ any;
+            setFormat(type: import("lexical").ElementFormatType): /*elided*/ any;
+            setStyle(style: string): /*elided*/ any;
+            setIndent(indentLevel: number): /*elided*/ any;
+            splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): /*elided*/ any;
+            canIndent(): boolean;
+            collapseAtStart(selection: RangeSelection): boolean;
+            excludeFromCopy(destination?: "clone" | "html"): boolean;
+            canReplaceWith(replacement: LexicalNode): boolean;
+            canInsertAfter(node: LexicalNode): boolean;
+            isShadowRoot(): boolean;
+            canMergeWith(node: ElementNode): boolean;
+            canMergeWhenEmpty(): boolean;
+            __type: string;
+            __key: string;
+            __parent: null | NodeKey;
+            __prev: null | NodeKey;
+            __next: null | NodeKey;
+            getType(): string;
+            isAttached(): boolean;
+            isSelected(selection?: null | BaseSelection): boolean;
+            getKey(): NodeKey;
+            getIndexWithinParent(): number;
+            getParent<T extends ElementNode>(): T | null;
+            getParentOrThrow<T extends ElementNode>(): T;
+            getParents(): Array<ElementNode>;
+            getParentKeys(): Array<NodeKey>;
+            getPreviousSibling<T extends LexicalNode>(): T | null;
+            getPreviousSiblings<T extends LexicalNode>(): Array<T>;
+            getNextSibling<T extends LexicalNode>(): T | null;
+            getNextSiblings<T extends LexicalNode>(): Array<T>;
+            getCommonAncestor<T extends ElementNode = ElementNodeType>(node: LexicalNode): T | null;
+            is(object: LexicalNode | null | undefined): boolean;
+            isBefore(targetNode: LexicalNode): boolean;
+            isParentOf(targetNode: LexicalNode): boolean;
+            getNodesBetween(targetNode: LexicalNode): Array<LexicalNode>;
+            getLatest(): /*elided*/ any;
+            getWritable(): /*elided*/ any;
+            remove(preserveEmptyParent?: boolean): void;
+            replace<N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N;
+            insertAfter(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            insertBefore(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            isParentRequired(): boolean;
+            createParentElementNode(): ElementNode;
+            selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            markDirty(): void;
+        };
+        transform(): ((node: LexicalNode) => void) | null;
+    } | undefined) => node is {
+        __fields: WrapperBlockFields;
+        canBeEmpty(): false;
+        canInsertTextAfter(): false;
+        canInsertTextBefore(): false;
+        createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
+        exportDOM(): DOMExportOutput;
+        exportJSON(): SerializedWrapperBlockNode;
+        extractWithChild(child: LexicalNode, selection: BaseSelection, destination: "clone" | "html"): boolean;
+        getFields(): WrapperBlockFields;
+        insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): ElementNodeType | null;
+        isInline(): true;
+        setFields(fields: WrapperBlockFields): void;
+        updateDOM(prevNode: /*elided*/ any, anchor: HTMLAnchorElement, config: EditorConfig): boolean;
+        getTopLevelElement(): ElementNode | null;
+        getTopLevelElementOrThrow(): ElementNode;
+        constructor: import("lexical").KlassConstructor<typeof ElementNode>;
+        __first: null | NodeKey;
+        __last: null | NodeKey;
+        __size: number;
+        __format: number;
+        __style: string;
+        __indent: number;
+        __dir: "ltr" | "rtl" | null;
+        afterCloneFrom(prevNode: /*elided*/ any): void;
+        getFormat(): number;
+        getFormatType(): import("lexical").ElementFormatType;
+        getStyle(): string;
+        getIndent(): number;
+        getChildren<T extends LexicalNode>(): Array<T>;
+        getChildrenKeys(): Array<NodeKey>;
+        getChildrenSize(): number;
+        isEmpty(): boolean;
+        isDirty(): boolean;
+        isLastChild(): boolean;
+        getAllTextNodes(): Array<import("lexical").TextNode>;
+        getFirstDescendant<T extends LexicalNode>(): T | null;
+        getLastDescendant<T extends LexicalNode>(): T | null;
+        getDescendantByIndex<T extends LexicalNode>(index: number): T | null;
+        getFirstChild<T extends LexicalNode>(): T | null;
+        getFirstChildOrThrow<T extends LexicalNode>(): T;
+        getLastChild<T extends LexicalNode>(): T | null;
+        getLastChildOrThrow<T extends LexicalNode>(): T;
+        getChildAtIndex<T extends LexicalNode>(index: number): T | null;
+        getTextContent(): string;
+        getTextContentSize(): number;
+        getDirection(): "ltr" | "rtl" | null;
+        hasFormat(type: import("lexical").ElementFormatType): boolean;
+        select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+        selectStart(): RangeSelection;
+        selectEnd(): RangeSelection;
+        clear(): /*elided*/ any;
+        append(...nodesToAppend: LexicalNode[]): /*elided*/ any;
+        setDirection(direction: "ltr" | "rtl" | null): /*elided*/ any;
+        setFormat(type: import("lexical").ElementFormatType): /*elided*/ any;
+        setStyle(style: string): /*elided*/ any;
+        setIndent(indentLevel: number): /*elided*/ any;
+        splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): /*elided*/ any;
+        canIndent(): boolean;
+        collapseAtStart(selection: RangeSelection): boolean;
+        excludeFromCopy(destination?: "clone" | "html"): boolean;
+        canReplaceWith(replacement: LexicalNode): boolean;
+        canInsertAfter(node: LexicalNode): boolean;
+        isShadowRoot(): boolean;
+        canMergeWith(node: ElementNode): boolean;
+        canMergeWhenEmpty(): boolean;
+        __type: string;
+        __key: string;
+        __parent: null | NodeKey;
+        __prev: null | NodeKey;
+        __next: null | NodeKey;
+        getType(): string;
+        isAttached(): boolean;
+        isSelected(selection?: null | BaseSelection): boolean;
+        getKey(): NodeKey;
+        getIndexWithinParent(): number;
+        getParent<T extends ElementNode>(): T | null;
+        getParentOrThrow<T extends ElementNode>(): T;
+        getParents(): Array<ElementNode>;
+        getParentKeys(): Array<NodeKey>;
+        getPreviousSibling<T extends LexicalNode>(): T | null;
+        getPreviousSiblings<T extends LexicalNode>(): Array<T>;
+        getNextSibling<T extends LexicalNode>(): T | null;
+        getNextSiblings<T extends LexicalNode>(): Array<T>;
+        getCommonAncestor<T extends ElementNode = ElementNodeType>(node: LexicalNode): T | null;
+        is(object: LexicalNode | null | undefined): boolean;
+        isBefore(targetNode: LexicalNode): boolean;
+        isParentOf(targetNode: LexicalNode): boolean;
+        getNodesBetween(targetNode: LexicalNode): Array<LexicalNode>;
+        getLatest(): /*elided*/ any;
+        getWritable(): /*elided*/ any;
+        remove(preserveEmptyParent?: boolean): void;
+        replace<N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N;
+        insertAfter(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+        insertBefore(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+        isParentRequired(): boolean;
+        createParentElementNode(): ElementNode;
+        selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+        selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
+        markDirty(): void;
+    };
+    WrapperBlockNode: {
+        new ({ fields, key }: {
+            fields: WrapperBlockFields;
+            key?: NodeKey;
+        }): {
+            __fields: WrapperBlockFields;
+            canBeEmpty(): false;
+            canInsertTextAfter(): false;
+            canInsertTextBefore(): false;
+            createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
+            exportDOM(): DOMExportOutput;
+            exportJSON(): SerializedWrapperBlockNode;
+            extractWithChild(child: LexicalNode, selection: BaseSelection, destination: "clone" | "html"): boolean;
+            getFields(): WrapperBlockFields;
+            insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): ElementNodeType | null;
+            isInline(): true;
+            setFields(fields: WrapperBlockFields): void;
+            updateDOM(prevNode: /*elided*/ any, anchor: HTMLAnchorElement, config: EditorConfig): boolean;
+            getTopLevelElement(): ElementNode | null;
+            getTopLevelElementOrThrow(): ElementNode;
+            constructor: import("lexical").KlassConstructor<typeof ElementNode>;
+            __first: null | NodeKey;
+            __last: null | NodeKey;
+            __size: number;
+            __format: number;
+            __style: string;
+            __indent: number;
+            __dir: "ltr" | "rtl" | null;
+            afterCloneFrom(prevNode: /*elided*/ any): void;
+            getFormat(): number;
+            getFormatType(): import("lexical").ElementFormatType;
+            getStyle(): string;
+            getIndent(): number;
+            getChildren<T extends LexicalNode>(): Array<T>;
+            getChildrenKeys(): Array<NodeKey>;
+            getChildrenSize(): number;
+            isEmpty(): boolean;
+            isDirty(): boolean;
+            isLastChild(): boolean;
+            getAllTextNodes(): Array<import("lexical").TextNode>;
+            getFirstDescendant<T extends LexicalNode>(): T | null;
+            getLastDescendant<T extends LexicalNode>(): T | null;
+            getDescendantByIndex<T extends LexicalNode>(index: number): T | null;
+            getFirstChild<T extends LexicalNode>(): T | null;
+            getFirstChildOrThrow<T extends LexicalNode>(): T;
+            getLastChild<T extends LexicalNode>(): T | null;
+            getLastChildOrThrow<T extends LexicalNode>(): T;
+            getChildAtIndex<T extends LexicalNode>(index: number): T | null;
+            getTextContent(): string;
+            getTextContentSize(): number;
+            getDirection(): "ltr" | "rtl" | null;
+            hasFormat(type: import("lexical").ElementFormatType): boolean;
+            select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+            selectStart(): RangeSelection;
+            selectEnd(): RangeSelection;
+            clear(): /*elided*/ any;
+            append(...nodesToAppend: LexicalNode[]): /*elided*/ any;
+            setDirection(direction: "ltr" | "rtl" | null): /*elided*/ any;
+            setFormat(type: import("lexical").ElementFormatType): /*elided*/ any;
+            setStyle(style: string): /*elided*/ any;
+            setIndent(indentLevel: number): /*elided*/ any;
+            splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): /*elided*/ any;
+            canIndent(): boolean;
+            collapseAtStart(selection: RangeSelection): boolean;
+            excludeFromCopy(destination?: "clone" | "html"): boolean;
+            canReplaceWith(replacement: LexicalNode): boolean;
+            canInsertAfter(node: LexicalNode): boolean;
+            isShadowRoot(): boolean;
+            canMergeWith(node: ElementNode): boolean;
+            canMergeWhenEmpty(): boolean;
+            __type: string;
+            __key: string;
+            __parent: null | NodeKey;
+            __prev: null | NodeKey;
+            __next: null | NodeKey;
+            getType(): string;
+            isAttached(): boolean;
+            isSelected(selection?: null | BaseSelection): boolean;
+            getKey(): NodeKey;
+            getIndexWithinParent(): number;
+            getParent<T extends ElementNode>(): T | null;
+            getParentOrThrow<T extends ElementNode>(): T;
+            getParents(): Array<ElementNode>;
+            getParentKeys(): Array<NodeKey>;
+            getPreviousSibling<T extends LexicalNode>(): T | null;
+            getPreviousSiblings<T extends LexicalNode>(): Array<T>;
+            getNextSibling<T extends LexicalNode>(): T | null;
+            getNextSiblings<T extends LexicalNode>(): Array<T>;
+            getCommonAncestor<T extends ElementNode = ElementNodeType>(node: LexicalNode): T | null;
+            is(object: LexicalNode | null | undefined): boolean;
+            isBefore(targetNode: LexicalNode): boolean;
+            isParentOf(targetNode: LexicalNode): boolean;
+            getNodesBetween(targetNode: LexicalNode): Array<LexicalNode>;
+            getLatest(): /*elided*/ any;
+            getWritable(): /*elided*/ any;
+            remove(preserveEmptyParent?: boolean): void;
+            replace<N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N;
+            insertAfter(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            insertBefore(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            isParentRequired(): boolean;
+            createParentElementNode(): ElementNode;
+            selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            markDirty(): void;
+        };
+        clone(node: {
+            __fields: WrapperBlockFields;
+            canBeEmpty(): false;
+            canInsertTextAfter(): false;
+            canInsertTextBefore(): false;
+            createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
+            exportDOM(): DOMExportOutput;
+            exportJSON(): SerializedWrapperBlockNode;
+            extractWithChild(child: LexicalNode, selection: BaseSelection, destination: "clone" | "html"): boolean;
+            getFields(): WrapperBlockFields;
+            insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): ElementNodeType | null;
+            isInline(): true;
+            setFields(fields: WrapperBlockFields): void;
+            updateDOM(prevNode: /*elided*/ any, anchor: HTMLAnchorElement, config: EditorConfig): boolean;
+            getTopLevelElement(): ElementNode | null;
+            getTopLevelElementOrThrow(): ElementNode;
+            constructor: import("lexical").KlassConstructor<typeof ElementNode>;
+            __first: null | NodeKey;
+            __last: null | NodeKey;
+            __size: number;
+            __format: number;
+            __style: string;
+            __indent: number;
+            __dir: "ltr" | "rtl" | null;
+            afterCloneFrom(prevNode: /*elided*/ any): void;
+            getFormat(): number;
+            getFormatType(): import("lexical").ElementFormatType;
+            getStyle(): string;
+            getIndent(): number;
+            getChildren<T extends LexicalNode>(): Array<T>;
+            getChildrenKeys(): Array<NodeKey>;
+            getChildrenSize(): number;
+            isEmpty(): boolean;
+            isDirty(): boolean;
+            isLastChild(): boolean;
+            getAllTextNodes(): Array<import("lexical").TextNode>;
+            getFirstDescendant<T extends LexicalNode>(): T | null;
+            getLastDescendant<T extends LexicalNode>(): T | null;
+            getDescendantByIndex<T extends LexicalNode>(index: number): T | null;
+            getFirstChild<T extends LexicalNode>(): T | null;
+            getFirstChildOrThrow<T extends LexicalNode>(): T;
+            getLastChild<T extends LexicalNode>(): T | null;
+            getLastChildOrThrow<T extends LexicalNode>(): T;
+            getChildAtIndex<T extends LexicalNode>(index: number): T | null;
+            getTextContent(): string;
+            getTextContentSize(): number;
+            getDirection(): "ltr" | "rtl" | null;
+            hasFormat(type: import("lexical").ElementFormatType): boolean;
+            select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+            selectStart(): RangeSelection;
+            selectEnd(): RangeSelection;
+            clear(): /*elided*/ any;
+            append(...nodesToAppend: LexicalNode[]): /*elided*/ any;
+            setDirection(direction: "ltr" | "rtl" | null): /*elided*/ any;
+            setFormat(type: import("lexical").ElementFormatType): /*elided*/ any;
+            setStyle(style: string): /*elided*/ any;
+            setIndent(indentLevel: number): /*elided*/ any;
+            splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): /*elided*/ any;
+            canIndent(): boolean;
+            collapseAtStart(selection: RangeSelection): boolean;
+            excludeFromCopy(destination?: "clone" | "html"): boolean;
+            canReplaceWith(replacement: LexicalNode): boolean;
+            canInsertAfter(node: LexicalNode): boolean;
+            isShadowRoot(): boolean;
+            canMergeWith(node: ElementNode): boolean;
+            canMergeWhenEmpty(): boolean;
+            __type: string;
+            __key: string;
+            __parent: null | NodeKey;
+            __prev: null | NodeKey;
+            __next: null | NodeKey;
+            getType(): string;
+            isAttached(): boolean;
+            isSelected(selection?: null | BaseSelection): boolean;
+            getKey(): NodeKey;
+            getIndexWithinParent(): number;
+            getParent<T extends ElementNode>(): T | null;
+            getParentOrThrow<T extends ElementNode>(): T;
+            getParents(): Array<ElementNode>;
+            getParentKeys(): Array<NodeKey>;
+            getPreviousSibling<T extends LexicalNode>(): T | null;
+            getPreviousSiblings<T extends LexicalNode>(): Array<T>;
+            getNextSibling<T extends LexicalNode>(): T | null;
+            getNextSiblings<T extends LexicalNode>(): Array<T>;
+            getCommonAncestor<T extends ElementNode = ElementNodeType>(node: LexicalNode): T | null;
+            is(object: LexicalNode | null | undefined): boolean;
+            isBefore(targetNode: LexicalNode): boolean;
+            isParentOf(targetNode: LexicalNode): boolean;
+            getNodesBetween(targetNode: LexicalNode): Array<LexicalNode>;
+            getLatest(): /*elided*/ any;
+            getWritable(): /*elided*/ any;
+            remove(preserveEmptyParent?: boolean): void;
+            replace<N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N;
+            insertAfter(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            insertBefore(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            isParentRequired(): boolean;
+            createParentElementNode(): ElementNode;
+            selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            markDirty(): void;
+        }): {
+            __fields: WrapperBlockFields;
+            canBeEmpty(): false;
+            canInsertTextAfter(): false;
+            canInsertTextBefore(): false;
+            createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
+            exportDOM(): DOMExportOutput;
+            exportJSON(): SerializedWrapperBlockNode;
+            extractWithChild(child: LexicalNode, selection: BaseSelection, destination: "clone" | "html"): boolean;
+            getFields(): WrapperBlockFields;
+            insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): ElementNodeType | null;
+            isInline(): true;
+            setFields(fields: WrapperBlockFields): void;
+            updateDOM(prevNode: /*elided*/ any, anchor: HTMLAnchorElement, config: EditorConfig): boolean;
+            getTopLevelElement(): ElementNode | null;
+            getTopLevelElementOrThrow(): ElementNode;
+            constructor: import("lexical").KlassConstructor<typeof ElementNode>;
+            __first: null | NodeKey;
+            __last: null | NodeKey;
+            __size: number;
+            __format: number;
+            __style: string;
+            __indent: number;
+            __dir: "ltr" | "rtl" | null;
+            afterCloneFrom(prevNode: /*elided*/ any): void;
+            getFormat(): number;
+            getFormatType(): import("lexical").ElementFormatType;
+            getStyle(): string;
+            getIndent(): number;
+            getChildren<T extends LexicalNode>(): Array<T>;
+            getChildrenKeys(): Array<NodeKey>;
+            getChildrenSize(): number;
+            isEmpty(): boolean;
+            isDirty(): boolean;
+            isLastChild(): boolean;
+            getAllTextNodes(): Array<import("lexical").TextNode>;
+            getFirstDescendant<T extends LexicalNode>(): T | null;
+            getLastDescendant<T extends LexicalNode>(): T | null;
+            getDescendantByIndex<T extends LexicalNode>(index: number): T | null;
+            getFirstChild<T extends LexicalNode>(): T | null;
+            getFirstChildOrThrow<T extends LexicalNode>(): T;
+            getLastChild<T extends LexicalNode>(): T | null;
+            getLastChildOrThrow<T extends LexicalNode>(): T;
+            getChildAtIndex<T extends LexicalNode>(index: number): T | null;
+            getTextContent(): string;
+            getTextContentSize(): number;
+            getDirection(): "ltr" | "rtl" | null;
+            hasFormat(type: import("lexical").ElementFormatType): boolean;
+            select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+            selectStart(): RangeSelection;
+            selectEnd(): RangeSelection;
+            clear(): /*elided*/ any;
+            append(...nodesToAppend: LexicalNode[]): /*elided*/ any;
+            setDirection(direction: "ltr" | "rtl" | null): /*elided*/ any;
+            setFormat(type: import("lexical").ElementFormatType): /*elided*/ any;
+            setStyle(style: string): /*elided*/ any;
+            setIndent(indentLevel: number): /*elided*/ any;
+            splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): /*elided*/ any;
+            canIndent(): boolean;
+            collapseAtStart(selection: RangeSelection): boolean;
+            excludeFromCopy(destination?: "clone" | "html"): boolean;
+            canReplaceWith(replacement: LexicalNode): boolean;
+            canInsertAfter(node: LexicalNode): boolean;
+            isShadowRoot(): boolean;
+            canMergeWith(node: ElementNode): boolean;
+            canMergeWhenEmpty(): boolean;
+            __type: string;
+            __key: string;
+            __parent: null | NodeKey;
+            __prev: null | NodeKey;
+            __next: null | NodeKey;
+            getType(): string;
+            isAttached(): boolean;
+            isSelected(selection?: null | BaseSelection): boolean;
+            getKey(): NodeKey;
+            getIndexWithinParent(): number;
+            getParent<T extends ElementNode>(): T | null;
+            getParentOrThrow<T extends ElementNode>(): T;
+            getParents(): Array<ElementNode>;
+            getParentKeys(): Array<NodeKey>;
+            getPreviousSibling<T extends LexicalNode>(): T | null;
+            getPreviousSiblings<T extends LexicalNode>(): Array<T>;
+            getNextSibling<T extends LexicalNode>(): T | null;
+            getNextSiblings<T extends LexicalNode>(): Array<T>;
+            getCommonAncestor<T extends ElementNode = ElementNodeType>(node: LexicalNode): T | null;
+            is(object: LexicalNode | null | undefined): boolean;
+            isBefore(targetNode: LexicalNode): boolean;
+            isParentOf(targetNode: LexicalNode): boolean;
+            getNodesBetween(targetNode: LexicalNode): Array<LexicalNode>;
+            getLatest(): /*elided*/ any;
+            getWritable(): /*elided*/ any;
+            remove(preserveEmptyParent?: boolean): void;
+            replace<N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N;
+            insertAfter(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            insertBefore(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            isParentRequired(): boolean;
+            createParentElementNode(): ElementNode;
+            selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            markDirty(): void;
+        };
+        getType(): string;
+        importDOM(): DOMConversionMap<HTMLDivElement> | null;
+        importJSON(serializedNode: SerializedWrapperBlockNode): {
+            __fields: WrapperBlockFields;
+            canBeEmpty(): false;
+            canInsertTextAfter(): false;
+            canInsertTextBefore(): false;
+            createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
+            exportDOM(): DOMExportOutput;
+            exportJSON(): SerializedWrapperBlockNode;
+            extractWithChild(child: LexicalNode, selection: BaseSelection, destination: "clone" | "html"): boolean;
+            getFields(): WrapperBlockFields;
+            insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): ElementNodeType | null;
+            isInline(): true;
+            setFields(fields: WrapperBlockFields): void;
+            updateDOM(prevNode: /*elided*/ any, anchor: HTMLAnchorElement, config: EditorConfig): boolean;
+            getTopLevelElement(): ElementNode | null;
+            getTopLevelElementOrThrow(): ElementNode;
+            constructor: import("lexical").KlassConstructor<typeof ElementNode>;
+            __first: null | NodeKey;
+            __last: null | NodeKey;
+            __size: number;
+            __format: number;
+            __style: string;
+            __indent: number;
+            __dir: "ltr" | "rtl" | null;
+            afterCloneFrom(prevNode: /*elided*/ any): void;
+            getFormat(): number;
+            getFormatType(): import("lexical").ElementFormatType;
+            getStyle(): string;
+            getIndent(): number;
+            getChildren<T extends LexicalNode>(): Array<T>;
+            getChildrenKeys(): Array<NodeKey>;
+            getChildrenSize(): number;
+            isEmpty(): boolean;
+            isDirty(): boolean;
+            isLastChild(): boolean;
+            getAllTextNodes(): Array<import("lexical").TextNode>;
+            getFirstDescendant<T extends LexicalNode>(): T | null;
+            getLastDescendant<T extends LexicalNode>(): T | null;
+            getDescendantByIndex<T extends LexicalNode>(index: number): T | null;
+            getFirstChild<T extends LexicalNode>(): T | null;
+            getFirstChildOrThrow<T extends LexicalNode>(): T;
+            getLastChild<T extends LexicalNode>(): T | null;
+            getLastChildOrThrow<T extends LexicalNode>(): T;
+            getChildAtIndex<T extends LexicalNode>(index: number): T | null;
+            getTextContent(): string;
+            getTextContentSize(): number;
+            getDirection(): "ltr" | "rtl" | null;
+            hasFormat(type: import("lexical").ElementFormatType): boolean;
+            select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+            selectStart(): RangeSelection;
+            selectEnd(): RangeSelection;
+            clear(): /*elided*/ any;
+            append(...nodesToAppend: LexicalNode[]): /*elided*/ any;
+            setDirection(direction: "ltr" | "rtl" | null): /*elided*/ any;
+            setFormat(type: import("lexical").ElementFormatType): /*elided*/ any;
+            setStyle(style: string): /*elided*/ any;
+            setIndent(indentLevel: number): /*elided*/ any;
+            splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): /*elided*/ any;
+            canIndent(): boolean;
+            collapseAtStart(selection: RangeSelection): boolean;
+            excludeFromCopy(destination?: "clone" | "html"): boolean;
+            canReplaceWith(replacement: LexicalNode): boolean;
+            canInsertAfter(node: LexicalNode): boolean;
+            isShadowRoot(): boolean;
+            canMergeWith(node: ElementNode): boolean;
+            canMergeWhenEmpty(): boolean;
+            __type: string;
+            __key: string;
+            __parent: null | NodeKey;
+            __prev: null | NodeKey;
+            __next: null | NodeKey;
+            getType(): string;
+            isAttached(): boolean;
+            isSelected(selection?: null | BaseSelection): boolean;
+            getKey(): NodeKey;
+            getIndexWithinParent(): number;
+            getParent<T extends ElementNode>(): T | null;
+            getParentOrThrow<T extends ElementNode>(): T;
+            getParents(): Array<ElementNode>;
+            getParentKeys(): Array<NodeKey>;
+            getPreviousSibling<T extends LexicalNode>(): T | null;
+            getPreviousSiblings<T extends LexicalNode>(): Array<T>;
+            getNextSibling<T extends LexicalNode>(): T | null;
+            getNextSiblings<T extends LexicalNode>(): Array<T>;
+            getCommonAncestor<T extends ElementNode = ElementNodeType>(node: LexicalNode): T | null;
+            is(object: LexicalNode | null | undefined): boolean;
+            isBefore(targetNode: LexicalNode): boolean;
+            isParentOf(targetNode: LexicalNode): boolean;
+            getNodesBetween(targetNode: LexicalNode): Array<LexicalNode>;
+            getLatest(): /*elided*/ any;
+            getWritable(): /*elided*/ any;
+            remove(preserveEmptyParent?: boolean): void;
+            replace<N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N;
+            insertAfter(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            insertBefore(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+            isParentRequired(): boolean;
+            createParentElementNode(): ElementNode;
+            selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
+            markDirty(): void;
+        };
+        transform(): ((node: LexicalNode) => void) | null;
+    };
+    WrapperBlockNodeInstance: {
+        __fields: WrapperBlockFields;
+        canBeEmpty(): false;
+        canInsertTextAfter(): false;
+        canInsertTextBefore(): false;
+        createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
+        exportDOM(): DOMExportOutput;
+        exportJSON(): SerializedWrapperBlockNode;
+        extractWithChild(child: LexicalNode, selection: BaseSelection, destination: "clone" | "html"): boolean;
+        getFields(): WrapperBlockFields;
+        insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): ElementNodeType | null;
+        isInline(): true;
+        setFields(fields: WrapperBlockFields): void;
+        updateDOM(prevNode: /*elided*/ any, anchor: HTMLAnchorElement, config: EditorConfig): boolean;
+        getTopLevelElement(): ElementNode | null;
+        getTopLevelElementOrThrow(): ElementNode;
+        constructor: import("lexical").KlassConstructor<typeof ElementNode>;
+        __first: null | NodeKey;
+        __last: null | NodeKey;
+        __size: number;
+        __format: number;
+        __style: string;
+        __indent: number;
+        __dir: "ltr" | "rtl" | null;
+        afterCloneFrom(prevNode: /*elided*/ any): void;
+        getFormat(): number;
+        getFormatType(): import("lexical").ElementFormatType;
+        getStyle(): string;
+        getIndent(): number;
+        getChildren<T extends LexicalNode>(): Array<T>;
+        getChildrenKeys(): Array<NodeKey>;
+        getChildrenSize(): number;
+        isEmpty(): boolean;
+        isDirty(): boolean;
+        isLastChild(): boolean;
+        getAllTextNodes(): Array<import("lexical").TextNode>;
+        getFirstDescendant<T extends LexicalNode>(): T | null;
+        getLastDescendant<T extends LexicalNode>(): T | null;
+        getDescendantByIndex<T extends LexicalNode>(index: number): T | null;
+        getFirstChild<T extends LexicalNode>(): T | null;
+        getFirstChildOrThrow<T extends LexicalNode>(): T;
+        getLastChild<T extends LexicalNode>(): T | null;
+        getLastChildOrThrow<T extends LexicalNode>(): T;
+        getChildAtIndex<T extends LexicalNode>(index: number): T | null;
+        getTextContent(): string;
+        getTextContentSize(): number;
+        getDirection(): "ltr" | "rtl" | null;
+        hasFormat(type: import("lexical").ElementFormatType): boolean;
+        select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+        selectStart(): RangeSelection;
+        selectEnd(): RangeSelection;
+        clear(): /*elided*/ any;
+        append(...nodesToAppend: LexicalNode[]): /*elided*/ any;
+        setDirection(direction: "ltr" | "rtl" | null): /*elided*/ any;
+        setFormat(type: import("lexical").ElementFormatType): /*elided*/ any;
+        setStyle(style: string): /*elided*/ any;
+        setIndent(indentLevel: number): /*elided*/ any;
+        splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): /*elided*/ any;
+        canIndent(): boolean;
+        collapseAtStart(selection: RangeSelection): boolean;
+        excludeFromCopy(destination?: "clone" | "html"): boolean;
+        canReplaceWith(replacement: LexicalNode): boolean;
+        canInsertAfter(node: LexicalNode): boolean;
+        isShadowRoot(): boolean;
+        canMergeWith(node: ElementNode): boolean;
+        canMergeWhenEmpty(): boolean;
+        __type: string;
+        __key: string;
+        __parent: null | NodeKey;
+        __prev: null | NodeKey;
+        __next: null | NodeKey;
+        getType(): string;
+        isAttached(): boolean;
+        isSelected(selection?: null | BaseSelection): boolean;
+        getKey(): NodeKey;
+        getIndexWithinParent(): number;
+        getParent<T extends ElementNode>(): T | null;
+        getParentOrThrow<T extends ElementNode>(): T;
+        getParents(): Array<ElementNode>;
+        getParentKeys(): Array<NodeKey>;
+        getPreviousSibling<T extends LexicalNode>(): T | null;
+        getPreviousSiblings<T extends LexicalNode>(): Array<T>;
+        getNextSibling<T extends LexicalNode>(): T | null;
+        getNextSiblings<T extends LexicalNode>(): Array<T>;
+        getCommonAncestor<T extends ElementNode = ElementNodeType>(node: LexicalNode): T | null;
+        is(object: LexicalNode | null | undefined): boolean;
+        isBefore(targetNode: LexicalNode): boolean;
+        isParentOf(targetNode: LexicalNode): boolean;
+        getNodesBetween(targetNode: LexicalNode): Array<LexicalNode>;
+        getLatest(): /*elided*/ any;
+        getWritable(): /*elided*/ any;
+        remove(preserveEmptyParent?: boolean): void;
+        replace<N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N;
+        insertAfter(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+        insertBefore(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+        isParentRequired(): boolean;
+        createParentElementNode(): ElementNode;
+        selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+        selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
+        markDirty(): void;
+    };
+};
+export type WrapperBlockNodeType = ReturnType<typeof getWrapperBlockNode>['WrapperBlockNodeInstance'];
+export type IsWrapperBlockNodeFn = ReturnType<typeof getWrapperBlockNode>['$isWrapperBlockNode'];
+export type CreateWrapperBlockNodeFn = ReturnType<typeof getWrapperBlockNode>['$createWrapperBlockNode'];
+//# sourceMappingURL=WrapperBlockNode.d.ts.map