@examind/block-types 0.1.18

package/types/lexical/nodes/LexicalTextNode.ts

@@ -0,0 +1,288 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+import type { EditorConfig, KlassConstructor, LexicalEditor, Spread } from '../LexicalEditor';
+import type { DOMConversionMap, DOMExportOutput, LexicalUpdateJSON, NodeKey, SerializedLexicalNode } from '../LexicalNode';
+import type { BaseSelection, RangeSelection } from '../LexicalSelection';
+import type { ElementNode } from './LexicalElementNode';
+import { LexicalNode } from '../LexicalNode';
+export type SerializedTextNode = Spread<{
+    detail: number;
+    format: number;
+    mode: TextModeType;
+    style: string;
+    text: string;
+}, SerializedLexicalNode>;
+export type TextDetailType = 'directionless' | 'unmergable';
+export type TextFormatType = 'bold' | 'underline' | 'strikethrough' | 'italic' | 'highlight' | 'code' | 'subscript' | 'superscript' | 'lowercase' | 'uppercase' | 'capitalize';
+export type TextModeType = 'normal' | 'token' | 'segmented';
+export type TextMark = {
+    end: null | number;
+    id: string;
+    start: null | number;
+};
+export type TextMarks = Array<TextMark>;
+export interface TextNode {
+    getTopLevelElement(): ElementNode | null;
+    getTopLevelElementOrThrow(): ElementNode;
+}
+/** @noInheritDoc */
+export declare class TextNode extends LexicalNode {
+    ['constructor']: KlassConstructor<typeof TextNode>;
+    __text: string;
+    /** @internal */
+    __format: number;
+    /** @internal */
+    __style: string;
+    /** @internal */
+    __mode: 0 | 1 | 2 | 3;
+    /** @internal */
+    __detail: number;
+    static getType(): string;
+    static clone(node: TextNode): TextNode;
+    afterCloneFrom(prevNode: this): void;
+    constructor(text?: string, key?: NodeKey);
+    /**
+     * Returns a 32-bit integer that represents the TextFormatTypes currently applied to the
+     * TextNode. You probably don't want to use this method directly - consider using TextNode.hasFormat instead.
+     *
+     * @returns a number representing the format of the text node.
+     */
+    getFormat(): number;
+    /**
+     * Returns a 32-bit integer that represents the TextDetailTypes currently applied to the
+     * TextNode. You probably don't want to use this method directly - consider using TextNode.isDirectionless
+     * or TextNode.isUnmergeable instead.
+     *
+     * @returns a number representing the detail of the text node.
+     */
+    getDetail(): number;
+    /**
+     * Returns the mode (TextModeType) of the TextNode, which may be "normal", "token", or "segmented"
+     *
+     * @returns TextModeType.
+     */
+    getMode(): TextModeType;
+    /**
+     * Returns the styles currently applied to the node. This is analogous to CSSText in the DOM.
+     *
+     * @returns CSSText-like string of styles applied to the underlying DOM node.
+     */
+    getStyle(): string;
+    /**
+     * Returns whether or not the node is in "token" mode. TextNodes in token mode can be navigated through character-by-character
+     * with a RangeSelection, but are deleted as a single entity (not individually by character).
+     *
+     * @returns true if the node is in token mode, false otherwise.
+     */
+    isToken(): boolean;
+    /**
+     *
+     * @returns true if Lexical detects that an IME or other 3rd-party script is attempting to
+     * mutate the TextNode, false otherwise.
+     */
+    isComposing(): boolean;
+    /**
+     * Returns whether or not the node is in "segmented" mode. TextNodes in segmented mode can be navigated through character-by-character
+     * with a RangeSelection, but are deleted in space-delimited "segments".
+     *
+     * @returns true if the node is in segmented mode, false otherwise.
+     */
+    isSegmented(): boolean;
+    /**
+     * Returns whether or not the node is "directionless". Directionless nodes don't respect changes between RTL and LTR modes.
+     *
+     * @returns true if the node is directionless, false otherwise.
+     */
+    isDirectionless(): boolean;
+    /**
+     * Returns whether or not the node is unmergeable. In some scenarios, Lexical tries to merge
+     * adjacent TextNodes into a single TextNode. If a TextNode is unmergeable, this won't happen.
+     *
+     * @returns true if the node is unmergeable, false otherwise.
+     */
+    isUnmergeable(): boolean;
+    /**
+     * Returns whether or not the node has the provided format applied. Use this with the human-readable TextFormatType
+     * string values to get the format of a TextNode.
+     *
+     * @param type - the TextFormatType to check for.
+     *
+     * @returns true if the node has the provided format, false otherwise.
+     */
+    hasFormat(type: TextFormatType): boolean;
+    /**
+     * Returns whether or not the node is simple text. Simple text is defined as a TextNode that has the string type "text"
+     * (i.e., not a subclass) and has no mode applied to it (i.e., not segmented or token).
+     *
+     * @returns true if the node is simple text, false otherwise.
+     */
+    isSimpleText(): boolean;
+    /**
+     * Returns the text content of the node as a string.
+     *
+     * @returns a string representing the text content of the node.
+     */
+    getTextContent(): string;
+    /**
+     * Returns the format flags applied to the node as a 32-bit integer.
+     *
+     * @returns a number representing the TextFormatTypes applied to the node.
+     */
+    getFormatFlags(type: TextFormatType, alignWithFormat: null | number): number;
+    /**
+     *
+     * @returns true if the text node supports font styling, false otherwise.
+     */
+    canHaveFormat(): boolean;
+    /**
+     * @returns true if the text node is inline, false otherwise.
+     */
+    isInline(): true;
+    createDOM(config: EditorConfig, editor?: LexicalEditor): HTMLElement;
+    updateDOM(prevNode: this, dom: HTMLElement, config: EditorConfig): boolean;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedTextNode): TextNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedTextNode>): this;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    exportJSON(): SerializedTextNode;
+    selectionTransform(prevSelection: null | BaseSelection, nextSelection: RangeSelection): void;
+    /**
+     * Sets the node format to the provided TextFormatType or 32-bit integer. Note that the TextFormatType
+     * version of the argument can only specify one format and doing so will remove all other formats that
+     * may be applied to the node. For toggling behavior, consider using {@link TextNode.toggleFormat}
+     *
+     * @param format - TextFormatType or 32-bit integer representing the node format.
+     *
+     * @returns this TextNode.
+     * // TODO 0.12 This should just be a `string`.
+     */
+    setFormat(format: TextFormatType | number): this;
+    /**
+     * Sets the node detail to the provided TextDetailType or 32-bit integer. Note that the TextDetailType
+     * version of the argument can only specify one detail value and doing so will remove all other detail values that
+     * may be applied to the node. For toggling behavior, consider using {@link TextNode.toggleDirectionless}
+     * or {@link TextNode.toggleUnmergeable}
+     *
+     * @param detail - TextDetailType or 32-bit integer representing the node detail.
+     *
+     * @returns this TextNode.
+     * // TODO 0.12 This should just be a `string`.
+     */
+    setDetail(detail: TextDetailType | number): this;
+    /**
+     * Sets the node style to the provided CSSText-like string. Set this property as you
+     * would an HTMLElement style attribute to apply inline styles to the underlying DOM Element.
+     *
+     * @param style - CSSText to be applied to the underlying HTMLElement.
+     *
+     * @returns this TextNode.
+     */
+    setStyle(style: string): this;
+    /**
+     * Applies the provided format to this TextNode if it's not present. Removes it if it's present.
+     * The subscript and superscript formats are mutually exclusive.
+     * Prefer using this method to turn specific formats on and off.
+     *
+     * @param type - TextFormatType to toggle.
+     *
+     * @returns this TextNode.
+     */
+    toggleFormat(type: TextFormatType): this;
+    /**
+     * Toggles the directionless detail value of the node. Prefer using this method over setDetail.
+     *
+     * @returns this TextNode.
+     */
+    toggleDirectionless(): this;
+    /**
+     * Toggles the unmergeable detail value of the node. Prefer using this method over setDetail.
+     *
+     * @returns this TextNode.
+     */
+    toggleUnmergeable(): this;
+    /**
+     * Sets the mode of the node.
+     *
+     * @returns this TextNode.
+     */
+    setMode(type: TextModeType): this;
+    /**
+     * Sets the text content of the node.
+     *
+     * @param text - the string to set as the text value of the node.
+     *
+     * @returns this TextNode.
+     */
+    setTextContent(text: string): this;
+    /**
+     * Sets the current Lexical selection to be a RangeSelection with anchor and focus on this TextNode at the provided offsets.
+     *
+     * @param _anchorOffset - the offset at which the Selection anchor will be placed.
+     * @param _focusOffset - the offset at which the Selection focus will be placed.
+     *
+     * @returns the new RangeSelection.
+     */
+    select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+    selectStart(): RangeSelection;
+    selectEnd(): RangeSelection;
+    /**
+     * Inserts the provided text into this TextNode at the provided offset, deleting the number of characters
+     * specified. Can optionally calculate a new selection after the operation is complete.
+     *
+     * @param offset - the offset at which the splice operation should begin.
+     * @param delCount - the number of characters to delete, starting from the offset.
+     * @param newText - the text to insert into the TextNode at the offset.
+     * @param moveSelection - optional, whether or not to move selection to the end of the inserted substring.
+     *
+     * @returns this TextNode.
+     */
+    spliceText(offset: number, delCount: number, newText: string, moveSelection?: boolean): TextNode;
+    /**
+     * This method is meant to be overridden by TextNode subclasses to control the behavior of those nodes
+     * when a user event would cause text to be inserted before them in the editor. If true, Lexical will attempt
+     * to insert text into this node. If false, it will insert the text in a new sibling node.
+     *
+     * @returns true if text can be inserted before the node, false otherwise.
+     */
+    canInsertTextBefore(): boolean;
+    /**
+     * This method is meant to be overridden by TextNode subclasses to control the behavior of those nodes
+     * when a user event would cause text to be inserted after them in the editor. If true, Lexical will attempt
+     * to insert text into this node. If false, it will insert the text in a new sibling node.
+     *
+     * @returns true if text can be inserted after the node, false otherwise.
+     */
+    canInsertTextAfter(): boolean;
+    /**
+     * Splits this TextNode at the provided character offsets, forming new TextNodes from the substrings
+     * formed by the split, and inserting those new TextNodes into the editor, replacing the one that was split.
+     *
+     * @param splitOffsets - rest param of the text content character offsets at which this node should be split.
+     *
+     * @returns an Array containing the newly-created TextNodes.
+     */
+    splitText(...splitOffsets: Array<number>): Array<TextNode>;
+    /**
+     * Merges the target TextNode into this TextNode, removing the target node.
+     *
+     * @param target - the TextNode to merge into this one.
+     *
+     * @returns this TextNode.
+     */
+    mergeWithSibling(target: TextNode): TextNode;
+    /**
+     * This method is meant to be overridden by TextNode subclasses to control the behavior of those nodes
+     * when used with the registerLexicalTextEntity function. If you're using registerLexicalTextEntity, the
+     * node class that you create and replace matched text with should return true from this method.
+     *
+     * @returns true if the node is to be treated as a "text entity", false otherwise.
+     */
+    isTextEntity(): boolean;
+}
+export declare function findParentPreDOMNode(node: Node): Node | null;
+export declare function $createTextNode(text?: string): TextNode;
+export declare function $isTextNode(node: LexicalNode | null | undefined): node is TextNode;

package/types/lexical/rich-text/index.ts

@@ -0,0 +1,53 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+import type { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalCommand, LexicalEditor, LexicalNode, LexicalUpdateJSON, NodeKey, ParagraphNode, PasteCommandType, RangeSelection, SerializedElementNode, Spread } from './../';
+import { ElementNode } from './../';
+export type SerializedHeadingNode = Spread<{
+    tag: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+}, SerializedElementNode>;
+export declare const DRAG_DROP_PASTE: LexicalCommand<Array<File>>;
+export type SerializedQuoteNode = SerializedElementNode;
+/** @noInheritDoc */
+export declare class QuoteNode extends ElementNode {
+    static getType(): string;
+    static clone(node: QuoteNode): QuoteNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: this, dom: HTMLElement): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    static importJSON(serializedNode: SerializedQuoteNode): QuoteNode;
+    insertNewAfter(_: RangeSelection, restoreSelection?: boolean): ParagraphNode;
+    collapseAtStart(): true;
+    canMergeWhenEmpty(): true;
+}
+export declare function $createQuoteNode(): QuoteNode;
+export declare function $isQuoteNode(node: LexicalNode | null | undefined): node is QuoteNode;
+export type HeadingTagType = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+/** @noInheritDoc */
+export declare class HeadingNode extends ElementNode {
+    /** @internal */
+    __tag: HeadingTagType;
+    static getType(): string;
+    static clone(node: HeadingNode): HeadingNode;
+    constructor(tag: HeadingTagType, key?: NodeKey);
+    getTag(): HeadingTagType;
+    setTag(tag: HeadingTagType): this;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: this, dom: HTMLElement, config: EditorConfig): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    static importJSON(serializedNode: SerializedHeadingNode): HeadingNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedHeadingNode>): this;
+    exportJSON(): SerializedHeadingNode;
+    insertNewAfter(selection?: RangeSelection, restoreSelection?: boolean): ParagraphNode | HeadingNode;
+    collapseAtStart(): true;
+    extractWithChild(): boolean;
+}
+export declare function $createHeadingNode(headingTag?: HeadingTagType): HeadingNode;
+export declare function $isHeadingNode(node: LexicalNode | null | undefined): node is HeadingNode;
+export declare function eventFiles(event: DragEvent | PasteCommandType): [boolean, Array<File>, boolean];
+export declare function registerRichText(editor: LexicalEditor): () => void;

package/types/lexical/table/LexicalTableCellNode.ts

@@ -0,0 +1,72 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+import type { DOMConversionMap, DOMConversionOutput, DOMExportOutput, EditorConfig, LexicalEditor, LexicalNode, LexicalUpdateJSON, NodeKey, SerializedElementNode, Spread } from './../';
+import { ElementNode } from './../';
+export declare const TableCellHeaderStates: {
+    BOTH: number;
+    COLUMN: number;
+    NO_STATUS: number;
+    ROW: number;
+};
+export type TableCellHeaderState = (typeof TableCellHeaderStates)[keyof typeof TableCellHeaderStates];
+export type SerializedTableCellNode = Spread<{
+    colSpan?: number;
+    rowSpan?: number;
+    headerState: TableCellHeaderState;
+    width?: number;
+    backgroundColor?: null | string;
+    verticalAlign?: string;
+}, SerializedElementNode>;
+/** @noInheritDoc */
+export declare class TableCellNode extends ElementNode {
+    /** @internal */
+    __colSpan: number;
+    /** @internal */
+    __rowSpan: number;
+    /** @internal */
+    __headerState: TableCellHeaderState;
+    /** @internal */
+    __width?: number | undefined;
+    /** @internal */
+    __backgroundColor: null | string;
+    /** @internal */
+    __verticalAlign?: undefined | string;
+    static getType(): string;
+    static clone(node: TableCellNode): TableCellNode;
+    afterCloneFrom(node: this): void;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedTableCellNode): TableCellNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedTableCellNode>): this;
+    constructor(headerState?: number, colSpan?: number, width?: number, key?: NodeKey);
+    createDOM(config: EditorConfig): HTMLTableCellElement;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    exportJSON(): SerializedTableCellNode;
+    getColSpan(): number;
+    setColSpan(colSpan: number): this;
+    getRowSpan(): number;
+    setRowSpan(rowSpan: number): this;
+    getTag(): 'th' | 'td';
+    setHeaderStyles(headerState: TableCellHeaderState, mask?: TableCellHeaderState): this;
+    getHeaderStyles(): TableCellHeaderState;
+    setWidth(width: number | undefined): this;
+    getWidth(): number | undefined;
+    getBackgroundColor(): null | string;
+    setBackgroundColor(newBackgroundColor: null | string): this;
+    getVerticalAlign(): undefined | string;
+    setVerticalAlign(newVerticalAlign: null | undefined | string): this;
+    toggleHeaderStyle(headerStateToToggle: TableCellHeaderState): this;
+    hasHeaderState(headerState: TableCellHeaderState): boolean;
+    hasHeader(): boolean;
+    updateDOM(prevNode: this): boolean;
+    isShadowRoot(): boolean;
+    collapseAtStart(): true;
+    canBeEmpty(): false;
+    canIndent(): false;
+}
+export declare function $convertTableCellNodeElement(domNode: Node): DOMConversionOutput;
+export declare function $createTableCellNode(headerState?: TableCellHeaderState, colSpan?: number, width?: number): TableCellNode;
+export declare function $isTableCellNode(node: LexicalNode | null | undefined): node is TableCellNode;

package/types/lexical/table/LexicalTableCommands.ts

@@ -0,0 +1,17 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+import type { LexicalCommand } from './../';
+export type InsertTableCommandPayloadHeaders = Readonly<{
+    rows: boolean;
+    columns: boolean;
+}> | boolean;
+export type InsertTableCommandPayload = Readonly<{
+    columns: string;
+    rows: string;
+    includeHeaders?: InsertTableCommandPayloadHeaders;
+}>;
+export declare const INSERT_TABLE_COMMAND: LexicalCommand<InsertTableCommandPayload>;

package/types/lexical/table/LexicalTableNode.ts

@@ -0,0 +1,65 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+import { BaseSelection, DOMConversionMap, DOMConversionOutput, DOMExportOutput, EditorConfig, ElementDOMSlot, ElementNode, LexicalEditor, LexicalNode, LexicalUpdateJSON, NodeKey, SerializedElementNode, Spread } from './../';
+import { type TableCellNode } from './LexicalTableCellNode';
+import { TableDOMCell, TableDOMTable } from './LexicalTableObserver';
+export type SerializedTableNode = Spread<{
+    colWidths?: readonly number[];
+    rowStriping?: boolean;
+    frozenColumnCount?: number;
+    frozenRowCount?: number;
+}, SerializedElementNode>;
+export declare function $isScrollableTablesActive(editor?: LexicalEditor): boolean;
+export declare function setScrollableTablesActive(editor: LexicalEditor, active: boolean): void;
+/** @noInheritDoc */
+export declare class TableNode extends ElementNode {
+    /** @internal */
+    __rowStriping: boolean;
+    __frozenColumnCount: number;
+    __frozenRowCount: number;
+    __colWidths?: readonly number[];
+    static getType(): string;
+    getColWidths(): readonly number[] | undefined;
+    setColWidths(colWidths: readonly number[] | undefined): this;
+    static clone(node: TableNode): TableNode;
+    afterCloneFrom(prevNode: this): void;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedTableNode): TableNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedTableNode>): this;
+    constructor(key?: NodeKey);
+    exportJSON(): SerializedTableNode;
+    extractWithChild(child: LexicalNode, selection: BaseSelection | null, destination: 'clone' | 'html'): boolean;
+    getDOMSlot(element: HTMLElement): ElementDOMSlot<HTMLTableElement>;
+    createDOM(config: EditorConfig, editor?: LexicalEditor): HTMLElement;
+    updateTableWrapper(prevNode: this | null, tableWrapper: HTMLDivElement, tableElement: HTMLTableElement, config: EditorConfig): void;
+    updateTableElement(prevNode: this | null, tableElement: HTMLTableElement, config: EditorConfig): void;
+    updateDOM(prevNode: this, dom: HTMLElement, config: EditorConfig): boolean;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    canBeEmpty(): false;
+    isShadowRoot(): boolean;
+    getCordsFromCellNode(tableCellNode: TableCellNode, table: TableDOMTable): {
+        x: number;
+        y: number;
+    };
+    getDOMCellFromCords(x: number, y: number, table: TableDOMTable): null | TableDOMCell;
+    getDOMCellFromCordsOrThrow(x: number, y: number, table: TableDOMTable): TableDOMCell;
+    getCellNodeFromCords(x: number, y: number, table: TableDOMTable): null | TableCellNode;
+    getCellNodeFromCordsOrThrow(x: number, y: number, table: TableDOMTable): TableCellNode;
+    getRowStriping(): boolean;
+    setRowStriping(newRowStriping: boolean): this;
+    setFrozenColumns(columnCount: number): this;
+    getFrozenColumns(): number;
+    setFrozenRows(rowCount: number): this;
+    getFrozenRows(): number;
+    canSelectBefore(): true;
+    canIndent(): false;
+    getColumnCount(): number;
+}
+export declare function $getElementForTableNode(editor: LexicalEditor, tableNode: TableNode): TableDOMTable;
+export declare function $convertTableElement(domNode: HTMLElement): DOMConversionOutput;
+export declare function $createTableNode(): TableNode;
+export declare function $isTableNode(node: LexicalNode | null | undefined): node is TableNode;

package/types/lexical/table/LexicalTableObserver.ts

@@ -0,0 +1,108 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+import type { LexicalEditor, NodeKey, TextFormatType } from './../';
+import { TableCellNode } from './LexicalTableCellNode';
+import { TableNode } from './LexicalTableNode';
+import { type TableSelection } from './LexicalTableSelection';
+import { HTMLTableElementWithWithTableSelectionState } from './LexicalTableSelectionHelpers';
+export type TableDOMCell = {
+    elem: HTMLElement;
+    highlighted: boolean;
+    hasBackgroundColor: boolean;
+    x: number;
+    y: number;
+};
+export type TableDOMRows = Array<Array<TableDOMCell | undefined> | undefined>;
+export type TableDOMTable = {
+    domRows: TableDOMRows;
+    columns: number;
+    rows: number;
+};
+export declare function $getTableAndElementByKey(tableNodeKey: NodeKey, editor?: LexicalEditor): {
+    tableNode: TableNode;
+    tableElement: HTMLTableElementWithWithTableSelectionState;
+};
+export declare class TableObserver {
+    focusX: number;
+    focusY: number;
+    listenersToRemove: Set<() => void>;
+    table: TableDOMTable;
+    isHighlightingCells: boolean;
+    anchorX: number;
+    anchorY: number;
+    tableNodeKey: NodeKey;
+    anchorCell: TableDOMCell | null;
+    focusCell: TableDOMCell | null;
+    anchorCellNodeKey: NodeKey | null;
+    focusCellNodeKey: NodeKey | null;
+    editor: LexicalEditor;
+    tableSelection: TableSelection | null;
+    hasHijackedSelectionStyles: boolean;
+    isSelecting: boolean;
+    pointerType: string | null;
+    shouldCheckSelection: boolean;
+    abortController: AbortController;
+    listenerOptions: {
+        signal: AbortSignal;
+    };
+    nextFocus: {
+        focusCell: TableDOMCell;
+        override: boolean;
+    } | null;
+    constructor(editor: LexicalEditor, tableNodeKey: string);
+    getTable(): TableDOMTable;
+    removeListeners(): void;
+    $lookup(): {
+        tableNode: TableNode;
+        tableElement: HTMLTableElementWithWithTableSelectionState;
+    };
+    trackTable(): void;
+    $clearHighlight(): void;
+    $enableHighlightStyle(): void;
+    $disableHighlightStyle(): void;
+    $updateTableTableSelection(selection: TableSelection | null): void;
+    /**
+     * @internal
+     * Firefox has a strange behavior where pressing the down arrow key from
+     * above the table will move the caret after the table and then lexical
+     * will select the last cell instead of the first.
+     * We do still want to let the browser handle caret movement but we will
+     * use this property to "tag" the update so that we can recheck the
+     * selection after the event is processed.
+     */
+    setShouldCheckSelection(): void;
+    /**
+     * @internal
+     */
+    getAndClearShouldCheckSelection(): boolean;
+    /**
+     * @internal
+     * When handling mousemove events we track what the focus cell should be, but
+     * the DOM selection may end up somewhere else entirely. We don't have an elegant
+     * way to handle this after the DOM selection has been resolved in a
+     * SELECTION_CHANGE_COMMAND callback.
+     */
+    setNextFocus(nextFocus: null | {
+        focusCell: TableDOMCell;
+        override: boolean;
+    }): void;
+    /** @internal */
+    getAndClearNextFocus(): {
+        focusCell: TableDOMCell;
+        override: boolean;
+    } | null;
+    /** @internal */
+    updateDOMSelection(): void;
+    $setFocusCellForSelection(cell: TableDOMCell, ignoreStart?: boolean): boolean;
+    $getAnchorTableCell(): TableCellNode | null;
+    $getAnchorTableCellOrThrow(): TableCellNode;
+    $getFocusTableCell(): TableCellNode | null;
+    $getFocusTableCellOrThrow(): TableCellNode;
+    $setAnchorCellForSelection(cell: TableDOMCell): void;
+    $formatCells(type: TextFormatType): void;
+    $clearText(): void;
+}

package/types/lexical/table/LexicalTablePluginHelpers.ts

@@ -0,0 +1,25 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+import { LexicalEditor } from './../';
+/**
+ * Register a transform to ensure that all TableCellNode have a colSpan and rowSpan of 1.
+ * This should only be registered when you do not want to support merged cells.
+ *
+ * @param editor The editor
+ * @returns An unregister callback
+ */
+export declare function registerTableCellUnmergeTransform(editor: LexicalEditor): () => void;
+export declare function registerTableSelectionObserver(editor: LexicalEditor, hasTabHandler?: boolean): () => void;
+/**
+ * Register the INSERT_TABLE_COMMAND listener and the table integrity transforms. The
+ * table selection observer should be registered separately after this with
+ * {@link registerTableSelectionObserver}.
+ *
+ * @param editor The editor
+ * @returns An unregister callback
+ */
+export declare function registerTablePlugin(editor: LexicalEditor): () => void;

package/types/lexical/table/LexicalTableRowNode.ts

@@ -0,0 +1,34 @@
+// THIS FILE IS AUTO-GENERATED
+// To regenerate, run: pnpm build (from the root of the project)
+
+// Type definitions based on Lexical
+// Original copyright: Meta Platforms, Inc. and affiliates.
+
+import type { BaseSelection, LexicalUpdateJSON, Spread } from './../';
+import { DOMConversionMap, DOMConversionOutput, EditorConfig, ElementNode, LexicalNode, NodeKey, SerializedElementNode } from './../';
+export type SerializedTableRowNode = Spread<{
+    height?: number;
+}, SerializedElementNode>;
+/** @noInheritDoc */
+export declare class TableRowNode extends ElementNode {
+    /** @internal */
+    __height?: number;
+    static getType(): string;
+    static clone(node: TableRowNode): TableRowNode;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedTableRowNode): TableRowNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedTableRowNode>): this;
+    constructor(height?: number, key?: NodeKey);
+    exportJSON(): SerializedTableRowNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    extractWithChild(child: LexicalNode, selection: BaseSelection | null, destination: 'clone' | 'html'): boolean;
+    isShadowRoot(): boolean;
+    setHeight(height?: number | undefined): this;
+    getHeight(): number | undefined;
+    updateDOM(prevNode: this): boolean;
+    canBeEmpty(): false;
+    canIndent(): false;
+}
+export declare function $convertTableRowElement(domNode: Node): DOMConversionOutput;
+export declare function $createTableRowNode(height?: number): TableRowNode;
+export declare function $isTableRowNode(node: LexicalNode | null | undefined): node is TableRowNode;