@lobehub/editor 3.3.2 → 3.4.0

package/es/editor-kernel/lexical/index.d.ts

@@ -0,0 +1,368 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export type {
+  BaseCaret,
+  CaretDirection,
+  CaretRange,
+  CaretType,
+  ChildCaret,
+  CommonAncestorResult,
+  CommonAncestorResultAncestor,
+  CommonAncestorResultBranch,
+  CommonAncestorResultDescendant,
+  CommonAncestorResultSame,
+  FlipDirection,
+  NodeCaret,
+  PointCaret,
+  RootMode,
+  SiblingCaret,
+  StepwiseIteratorConfig,
+  TextPointCaret,
+  TextPointCaretSlice,
+  TextPointCaretSliceTuple,
+} from './caret/LexicalCaret';
+export {
+  $comparePointCaretNext,
+  $extendCaretToRange,
+  $getAdjacentChildCaret,
+  $getCaretRange,
+  $getChildCaret,
+  $getChildCaretOrSelf,
+  $getCollapsedCaretRange,
+  $getCommonAncestor,
+  $getCommonAncestorResultBranchOrder,
+  $getSiblingCaret,
+  $getTextNodeOffset,
+  $getTextPointCaret,
+  $getTextPointCaretSlice,
+  $isChildCaret,
+  $isNodeCaret,
+  $isSiblingCaret,
+  $isTextPointCaret,
+  $isTextPointCaretSlice,
+  flipDirection,
+  makeStepwiseIterator,
+} from './caret/LexicalCaret';
+export {
+  $caretFromPoint,
+  $caretRangeFromSelection,
+  $getAdjacentSiblingOrParentSiblingCaret,
+  $getCaretInDirection,
+  $getCaretRangeInDirection,
+  $getChildCaretAtIndex,
+  $isExtendableTextPointCaret,
+  $normalizeCaret,
+  $removeTextFromCaretRange,
+  $rewindSiblingCaret,
+  $setPointFromCaret,
+  $setSelectionFromCaretRange,
+  $splitAtPointCaretNext,
+  $updateRangeSelectionFromCaretRange,
+  type SplitAtPointCaretNextOptions,
+} from './caret/LexicalCaretUtils';
+export {
+  BEFORE_INPUT_COMMAND,
+  BLUR_COMMAND,
+  CAN_REDO_COMMAND,
+  CAN_UNDO_COMMAND,
+  CLEAR_EDITOR_COMMAND,
+  CLEAR_HISTORY_COMMAND,
+  CLICK_COMMAND,
+  COMPOSITION_END_COMMAND,
+  COMPOSITION_START_COMMAND,
+  CONTROLLED_TEXT_INSERTION_COMMAND,
+  COPY_COMMAND,
+  createCommand,
+  CUT_COMMAND,
+  DELETE_CHARACTER_COMMAND,
+  DELETE_LINE_COMMAND,
+  DELETE_WORD_COMMAND,
+  DRAGEND_COMMAND,
+  DRAGOVER_COMMAND,
+  DRAGSTART_COMMAND,
+  DROP_COMMAND,
+  FOCUS_COMMAND,
+  FORMAT_ELEMENT_COMMAND,
+  FORMAT_TEXT_COMMAND,
+  INDENT_CONTENT_COMMAND,
+  INPUT_COMMAND,
+  INSERT_LINE_BREAK_COMMAND,
+  INSERT_PARAGRAPH_COMMAND,
+  INSERT_TAB_COMMAND,
+  KEY_ARROW_DOWN_COMMAND,
+  KEY_ARROW_LEFT_COMMAND,
+  KEY_ARROW_RIGHT_COMMAND,
+  KEY_ARROW_UP_COMMAND,
+  KEY_BACKSPACE_COMMAND,
+  KEY_DELETE_COMMAND,
+  KEY_DOWN_COMMAND,
+  KEY_ENTER_COMMAND,
+  KEY_ESCAPE_COMMAND,
+  KEY_MODIFIER_COMMAND,
+  KEY_SPACE_COMMAND,
+  KEY_TAB_COMMAND,
+  MOVE_TO_END,
+  MOVE_TO_START,
+  OUTDENT_CONTENT_COMMAND,
+  PASTE_COMMAND,
+  type PasteCommandType,
+  REDO_COMMAND,
+  REMOVE_TEXT_COMMAND,
+  SELECT_ALL_COMMAND,
+  SELECTION_CHANGE_COMMAND,
+  SELECTION_INSERT_CLIPBOARD_NODES_COMMAND,
+  UNDO_COMMAND,
+} from './LexicalCommands';
+export {
+  IS_ALL_FORMATTING,
+  IS_BOLD,
+  IS_CODE,
+  IS_HIGHLIGHT,
+  IS_ITALIC,
+  IS_STRIKETHROUGH,
+  IS_SUBSCRIPT,
+  IS_SUPERSCRIPT,
+  IS_UNDERLINE,
+  NODE_STATE_KEY,
+  TEXT_TYPE_TO_FORMAT,
+} from './LexicalConstants';
+export type {
+  CommandListener,
+  CommandListenerPriority,
+  CommandPayloadType,
+  CreateEditorArgs,
+  EditableListener,
+  EditorConfig,
+  EditorSetOptions,
+  EditorThemeClasses,
+  EditorThemeClassName,
+  EditorUpdateOptions,
+  HTMLConfig,
+  Klass,
+  KlassConstructor,
+  LexicalCommand,
+  LexicalEditor,
+  LexicalNodeConfig,
+  LexicalNodeReplacement,
+  MutationListener,
+  NodeMutation,
+  RootListener,
+  SerializedEditor,
+  Spread,
+  Transform,
+  UpdateListener,
+  UpdateListenerPayload,
+} from './LexicalEditor';
+export {
+  COMMAND_PRIORITY_CRITICAL,
+  COMMAND_PRIORITY_EDITOR,
+  COMMAND_PRIORITY_HIGH,
+  COMMAND_PRIORITY_LOW,
+  COMMAND_PRIORITY_NORMAL,
+  createEditor,
+  getTransformSetFromKlass,
+} from './LexicalEditor';
+export type {
+  EditorState,
+  EditorStateReadOptions,
+  SerializedEditorState,
+} from './LexicalEditorState';
+export { $isEditorState } from './LexicalEditorState';
+export type { EventHandler } from './LexicalEvents';
+export type {
+  BaseStaticNodeConfig,
+  DOMChildConversion,
+  DOMConversion,
+  DOMConversionFn,
+  DOMConversionMap,
+  DOMConversionOutput,
+  DOMConversionProp,
+  DOMConversionPropByTagName,
+  DOMConversionTagNameMap,
+  DOMExportOutput,
+  DOMExportOutputMap,
+  LexicalExportJSON,
+  LexicalNode,
+  LexicalUpdateJSON,
+  NodeKey,
+  NodeMap,
+  SerializedLexicalNode,
+  StaticNodeConfig,
+  StaticNodeConfigRecord,
+  StaticNodeConfigValue,
+} from './LexicalNode';
+export { buildImportMap } from './LexicalNode';
+export {
+  $getState,
+  $getStateChange,
+  $getWritableNodeState,
+  $setState,
+  type AnyStateConfig,
+  createSharedNodeState,
+  createState,
+  type NodeStateJSON,
+  type StateConfig,
+  type StateConfigKey,
+  type StateConfigValue,
+  type StateValueConfig,
+  type StateValueOrUpdater,
+  type ValueOrUpdater,
+} from './LexicalNodeState';
+export { $normalizeSelection as $normalizeSelection__EXPERIMENTAL } from './LexicalNormalization';
+export type {
+  BaseSelection,
+  ElementPointType as ElementPoint,
+  NodeSelection,
+  Point,
+  PointType,
+  RangeSelection,
+  TextPointType as TextPoint,
+} from './LexicalSelection';
+export {
+  $createNodeSelection,
+  $createPoint,
+  $createRangeSelection,
+  $createRangeSelectionFromDom,
+  $getCharacterOffsets,
+  $getPreviousSelection,
+  $getSelection,
+  $getTextContent,
+  $insertNodes,
+  $isBlockElementNode,
+  $isNodeSelection,
+  $isRangeSelection,
+} from './LexicalSelection';
+export { $parseSerializedNode, isCurrentlyReadOnlyMode } from './LexicalUpdates';
+export {
+  $addUpdateTag,
+  $applyNodeReplacement,
+  $cloneWithProperties,
+  $cloneWithPropertiesEphemeral,
+  $copyNode,
+  $create,
+  $findMatchingParent,
+  $getAdjacentNode,
+  $getEditor,
+  $getNearestNodeFromDOMNode,
+  $getNearestRootOrShadowRoot,
+  $getNodeByKey,
+  $getNodeByKeyOrThrow,
+  $getNodeFromDOMNode,
+  $getRoot,
+  $hasAncestor,
+  $hasUpdateTag,
+  $isInlineElementOrDecoratorNode,
+  $isLeafNode,
+  $isRootOrShadowRoot,
+  $isTokenOrSegmented,
+  $isTokenOrTab,
+  $nodesOfType,
+  $onUpdate,
+  $selectAll,
+  $setCompositionKey,
+  $setSelection,
+  $splitNode,
+  getDOMOwnerDocument,
+  getDOMSelection,
+  getDOMSelectionFromTarget,
+  getDOMTextNode,
+  getEditorPropertyFromDOMNode,
+  getNearestEditorFromDOMNode,
+  getRegisteredNode,
+  getRegisteredNodeOrThrow,
+  getStaticNodeConfig,
+  getTextDirection,
+  INTERNAL_$isBlock,
+  isBlockDomNode,
+  isDocumentFragment,
+  isDOMDocumentNode,
+  isDOMNode,
+  isDOMTextNode,
+  isDOMUnmanaged,
+  isExactShortcutMatch,
+  isHTMLAnchorElement,
+  isHTMLElement,
+  isInlineDomNode,
+  isLexicalEditor,
+  isModifierMatch,
+  isSelectionCapturedInDecoratorInput,
+  isSelectionWithinEditor,
+  removeFromParent,
+  resetRandomKey,
+  setDOMUnmanaged,
+  setNodeIndentFromDOM,
+} from './LexicalUtils';
+export { ArtificialNode__DO_NOT_USE } from './nodes/ArtificialNode';
+export { $isDecoratorNode, DecoratorNode } from './nodes/LexicalDecoratorNode';
+export type {
+  ElementDOMSlot,
+  ElementFormatType,
+  SerializedElementNode,
+} from './nodes/LexicalElementNode';
+export { $isElementNode, ElementNode } from './nodes/LexicalElementNode';
+export type { SerializedLineBreakNode } from './nodes/LexicalLineBreakNode';
+export {
+  $createLineBreakNode,
+  $isLineBreakNode,
+  LineBreakNode,
+} from './nodes/LexicalLineBreakNode';
+export type { SerializedParagraphNode } from './nodes/LexicalParagraphNode';
+export {
+  $createParagraphNode,
+  $isParagraphNode,
+  ParagraphNode,
+} from './nodes/LexicalParagraphNode';
+export type { SerializedRootNode } from './nodes/LexicalRootNode';
+export { $isRootNode, RootNode } from './nodes/LexicalRootNode';
+export type { SerializedTabNode } from './nodes/LexicalTabNode';
+export { $createTabNode, $isTabNode, TabNode } from './nodes/LexicalTabNode';
+export type { SerializedTextNode, TextFormatType, TextModeType } from './nodes/LexicalTextNode';
+export { $createTextNode, $isTextNode, TextNode } from './nodes/LexicalTextNode';
+export {
+  COLLABORATION_TAG,
+  HISTORIC_TAG,
+  HISTORY_MERGE_TAG,
+  HISTORY_PUSH_TAG,
+  PASTE_TAG,
+  SKIP_COLLAB_TAG,
+  SKIP_DOM_SELECTION_TAG,
+  SKIP_SCROLL_INTO_VIEW_TAG,
+  SKIP_SELECTION_FOCUS_TAG,
+  type UpdateTag,
+} from './LexicalUpdateTags';
+export {
+  type AnyLexicalExtension,
+  type AnyLexicalExtensionArgument,
+  type AnyNormalizedLexicalExtensionArgument,
+  configExtension,
+  type configTypeSymbol,
+  declarePeerDependency,
+  defineExtension,
+  type ExtensionBuildState,
+  type ExtensionConfigBase,
+  type ExtensionInitState,
+  type ExtensionRegisterState,
+  type InitialEditorConfig,
+  type InitialEditorStateType,
+  type initTypeSymbol,
+  type LexicalEditorWithDispose,
+  type LexicalExtension,
+  type LexicalExtensionArgument,
+  type LexicalExtensionConfig,
+  type LexicalExtensionDependency,
+  type LexicalExtensionInit,
+  type LexicalExtensionInternal,
+  type LexicalExtensionName,
+  type LexicalExtensionOutput,
+  type NormalizedLexicalExtensionArgument,
+  type NormalizedPeerDependency,
+  type OutputComponentExtension,
+  type outputTypeSymbol,
+  safeCast,
+  shallowMergeConfig,
+} from './extension-core';

package/es/editor-kernel/lexical/nodes/ArtificialNode.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { EditorConfig } from 'lexical';
+
+import { ElementNode } from './LexicalElementNode';
+
+/** @internal */
+export declare class ArtificialNode__DO_NOT_USE extends ElementNode {
+  static getType(): string;
+  createDOM(config: EditorConfig): HTMLElement;
+}

package/es/editor-kernel/lexical/nodes/LexicalDecoratorNode.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { EditorConfig } from 'lexical';
+
+import type { KlassConstructor, LexicalEditor } from '../LexicalEditor';
+import { LexicalNode } from '../LexicalNode';
+import type { ElementNode } from './LexicalElementNode';
+
+export interface DecoratorNode<T> {
+  getTopLevelElement(): ElementNode | this | null;
+  getTopLevelElementOrThrow(): ElementNode | this;
+}
+/** @noInheritDoc */
+export declare class DecoratorNode<T> extends LexicalNode {
+  /** @internal */
+  ['constructor']: KlassConstructor<typeof DecoratorNode<T>>;
+  /**
+   * The returned value is added to the LexicalEditor._decorators
+   */
+  decorate(editor: LexicalEditor, config: EditorConfig): null | T;
+  isIsolated(): boolean;
+  isInline(): boolean;
+  isKeyboardSelectable(): boolean;
+}
+export declare function $isDecoratorNode<T>(
+  node: LexicalNode | null | undefined,
+): node is DecoratorNode<T>;

package/es/editor-kernel/lexical/nodes/LexicalElementNode.d.ts

@@ -0,0 +1,235 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type {
+  KlassConstructor,
+  LexicalEditor,
+  LexicalUpdateJSON,
+  Spread,
+  TextFormatType,
+} from 'lexical';
+
+import type {
+  DOMExportOutput,
+  LexicalPrivateDOM,
+  NodeKey,
+  SerializedLexicalNode,
+} from '../LexicalNode';
+import { LexicalNode } from '../LexicalNode';
+import type { BaseSelection, RangeSelection } from '../LexicalSelection';
+import { TextNode } from '../index';
+
+export type SerializedElementNode<T extends SerializedLexicalNode = SerializedLexicalNode> = Spread<
+  {
+    children: Array<T>;
+    direction: 'ltr' | 'rtl' | null;
+    format: ElementFormatType;
+    indent: number;
+    textFormat?: number;
+    textStyle?: string;
+  },
+  SerializedLexicalNode
+>;
+export type ElementFormatType = 'left' | 'start' | 'center' | 'right' | 'end' | 'justify' | '';
+export interface ElementNode {
+  getTopLevelElement(): ElementNode | null;
+  getTopLevelElementOrThrow(): ElementNode;
+}
+/**
+ * A utility class for managing the DOM children of an ElementNode
+ */
+export declare class ElementDOMSlot<T extends HTMLElement = HTMLElement> {
+  readonly element: T;
+  readonly before: Node | null;
+  readonly after: Node | null;
+  constructor(
+    /** The element returned by createDOM */
+    element: T,
+    /** All managed children will be inserted before this node, if defined */
+    before?: Node | undefined | null,
+    /** All managed children will be inserted after this node, if defined */
+    after?: Node | undefined | null,
+  );
+  /**
+   * Return a new ElementDOMSlot where all managed children will be inserted before this node
+   */
+  withBefore(before: Node | undefined | null): ElementDOMSlot<T>;
+  /**
+   * Return a new ElementDOMSlot where all managed children will be inserted after this node
+   */
+  withAfter(after: Node | undefined | null): ElementDOMSlot<T>;
+  /**
+   * Return a new ElementDOMSlot with an updated root element
+   */
+  withElement<ElementType extends HTMLElement>(element: ElementType): ElementDOMSlot<ElementType>;
+  /**
+   * Insert the given child before this.before and any reconciler managed line break node,
+   * or append it if this.before is not defined
+   */
+  insertChild(dom: Node): this;
+  /**
+   * Remove the managed child from this container, will throw if it was not already there
+   */
+  removeChild(dom: Node): this;
+  /**
+   * Replace managed child prevDom with dom. Will throw if prevDom is not a child
+   *
+   * @param dom The new node to replace prevDom
+   * @param prevDom the node that will be replaced
+   */
+  replaceChild(dom: Node, prevDom: Node): this;
+  /**
+   * Returns the first managed child of this node,
+   * which will either be this.after.nextSibling or this.element.firstChild,
+   * and will never be this.before if it is defined.
+   */
+  getFirstChild(): ChildNode | null;
+  /**
+   * @internal
+   */
+  getManagedLineBreak(): Exclude<LexicalPrivateDOM['__lexicalLineBreak'], undefined>;
+  /** @internal */
+  setManagedLineBreak(lineBreakType: null | 'empty' | 'line-break' | 'decorator'): void;
+  /** @internal */
+  removeManagedLineBreak(): void;
+  /** @internal */
+  insertManagedLineBreak(webkitHack: boolean): void;
+  /**
+   * @internal
+   *
+   * Returns the offset of the first child
+   */
+  getFirstChildOffset(): number;
+  /**
+   * @internal
+   */
+  resolveChildIndex(
+    element: ElementNode,
+    elementDOM: HTMLElement,
+    initialDOM: Node,
+    initialOffset: number,
+  ): [node: ElementNode, idx: number];
+}
+export declare function indexPath(root: HTMLElement, child: Node): number[];
+/** @noInheritDoc */
+export declare class ElementNode extends LexicalNode {
+  /** @internal */
+  ['constructor']: KlassConstructor<typeof ElementNode>;
+  /** @internal */
+  __first: null | NodeKey;
+  /** @internal */
+  __last: null | NodeKey;
+  /** @internal */
+  __size: number;
+  /** @internal */
+  __format: number;
+  /** @internal */
+  __style: string;
+  /** @internal */
+  __indent: number;
+  /** @internal */
+  __dir: 'ltr' | 'rtl' | null;
+  /** @internal */
+  __textFormat: number;
+  /** @internal */
+  __textStyle: string;
+  constructor(key?: NodeKey);
+  afterCloneFrom(prevNode: this): void;
+  getFormat(): number;
+  getFormatType(): ElementFormatType;
+  getStyle(): string;
+  getIndent(): number;
+  getChildren<T extends LexicalNode>(): Array<T>;
+  getChildrenKeys(): Array<NodeKey>;
+  getChildrenSize(): number;
+  isEmpty(): boolean;
+  isDirty(): boolean;
+  isLastChild(): boolean;
+  getAllTextNodes(): Array<TextNode>;
+  getFirstDescendant<T extends LexicalNode>(): null | T;
+  getLastDescendant<T extends LexicalNode>(): null | T;
+  getDescendantByIndex<T extends LexicalNode>(index: number): null | T;
+  getFirstChild<T extends LexicalNode>(): null | T;
+  getFirstChildOrThrow<T extends LexicalNode>(): T;
+  getLastChild<T extends LexicalNode>(): null | T;
+  getLastChildOrThrow<T extends LexicalNode>(): T;
+  getChildAtIndex<T extends LexicalNode>(index: number): null | T;
+  getTextContent(): string;
+  getTextContentSize(): number;
+  getDirection(): 'ltr' | 'rtl' | null;
+  getTextFormat(): number;
+  hasFormat(type: ElementFormatType): boolean;
+  hasTextFormat(type: TextFormatType): boolean;
+  /**
+   * 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;
+  getTextStyle(): string;
+  select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+  selectStart(): RangeSelection;
+  selectEnd(): RangeSelection;
+  clear(): this;
+  append(...nodesToAppend: LexicalNode[]): this;
+  setDirection(direction: 'ltr' | 'rtl' | null): this;
+  setFormat(type: ElementFormatType): this;
+  setStyle(style: string): this;
+  setTextFormat(type: number): this;
+  setTextStyle(style: string): this;
+  setIndent(indentLevel: number): this;
+  splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): this;
+  /**
+   * @internal
+   *
+   * An experimental API that an ElementNode can override to control where its
+   * children are inserted into the DOM, this is useful to add a wrapping node
+   * or accessory nodes before or after the children. The root of the node returned
+   * by createDOM must still be exactly one HTMLElement.
+   */
+  getDOMSlot(element: HTMLElement): ElementDOMSlot<HTMLElement>;
+  exportDOM(editor: LexicalEditor): DOMExportOutput;
+  exportJSON(): SerializedElementNode;
+  updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedElementNode>): this;
+  insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): null | LexicalNode;
+  canIndent(): boolean;
+  collapseAtStart(selection: RangeSelection): boolean;
+  excludeFromCopy(destination?: 'clone' | 'html'): boolean;
+  /** @deprecated @internal */
+  canReplaceWith(replacement: LexicalNode): boolean;
+  /** @deprecated @internal */
+  canInsertAfter(node: LexicalNode): boolean;
+  canBeEmpty(): boolean;
+  canInsertTextBefore(): boolean;
+  canInsertTextAfter(): boolean;
+  isInline(): boolean;
+  isShadowRoot(): boolean;
+  /** @deprecated @internal */
+  canMergeWith(node: ElementNode): boolean;
+  extractWithChild(
+    child: LexicalNode,
+    selection: BaseSelection | null,
+    destination: 'clone' | 'html',
+  ): boolean;
+  /**
+   * Determines whether this node, when empty, can merge with a first block
+   * of nodes being inserted.
+   *
+   * This method is specifically called in {@link RangeSelection.insertNodes}
+   * to determine merging behavior during nodes insertion.
+   *
+   * @example
+   * // In a ListItemNode or QuoteNode implementation:
+   * canMergeWhenEmpty(): true {
+   *  return true;
+   * }
+   */
+  canMergeWhenEmpty(): boolean;
+  /** @internal */
+  reconcileObservedMutation(dom: HTMLElement, editor: LexicalEditor): void;
+}
+export declare function $isElementNode(node: LexicalNode | null | undefined): node is ElementNode;

package/es/editor-kernel/lexical/nodes/LexicalLineBreakNode.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { KlassConstructor } from '../LexicalEditor';
+import type { DOMConversionMap, NodeKey, SerializedLexicalNode } from '../LexicalNode';
+import { LexicalNode } from '../LexicalNode';
+
+export type SerializedLineBreakNode = SerializedLexicalNode;
+/** @noInheritDoc */
+export declare class LineBreakNode extends LexicalNode {
+  /** @internal */
+  ['constructor']: KlassConstructor<typeof LineBreakNode>;
+  static getType(): string;
+  static clone(node: LineBreakNode): LineBreakNode;
+  constructor(key?: NodeKey);
+  getTextContent(): '\n';
+  createDOM(): HTMLElement;
+  updateDOM(): false;
+  isInline(): true;
+  static importDOM(): DOMConversionMap | null;
+  static importJSON(serializedLineBreakNode: SerializedLineBreakNode): LineBreakNode;
+}
+export declare function $createLineBreakNode(): LineBreakNode;
+export declare function $isLineBreakNode(
+  node: LexicalNode | null | undefined,
+): node is LineBreakNode;