@tiptap/core 3.0.0-next.2 → 3.0.0-next.4

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-import { EditorState, Plugin, Transaction, PluginKey, Selection, NodeSelection, TextSelection } from '@tiptap/pm/state';
-import { NodeType, NodeSpec, Node as Node$1, DOMOutputSpec, MarkType, MarkSpec, Mark as Mark$1, Slice, ParseOptions, Schema, ResolvedPos, Fragment, ContentMatch, ParseRule } from '@tiptap/pm/model';
+import { Transaction, EditorState, Plugin, Selection, NodeSelection, TextSelection, PluginKey } from '@tiptap/pm/state';
+import { Node as Node$1, NodeType as NodeType$1, NodeSpec, DOMOutputSpec, MarkType as MarkType$1, MarkSpec, Mark as Mark$1, Slice, ParseOptions, Fragment, Schema, ContentMatch, ResolvedPos, ParseRule } from '@tiptap/pm/model';
 import { NodeView as NodeView$1, EditorProps, EditorView, Decoration, DecorationAttrs, ViewMutationRecord, NodeViewConstructor } from '@tiptap/pm/view';
-import { Mappable, Transform } from '@tiptap/pm/transform';
-import * as prosemirror_model from 'prosemirror-model';
+import { Transform, Mappable } from '@tiptap/pm/transform';
 
 type StringKeyOf<T> = Extract<keyof T, string>;
 type CallbackType<T extends Record<string, any>, EventName extends StringKeyOf<T>> = T[EventName] extends any[] ? T[EventName] : [T[EventName]];
@@ -16,6 +15,24 @@ declare class EventEmitter<T extends Record<string, any>> {
     removeAllListeners(): void;
 }
 
+/**
+ * Returns a new `Transform` based on all steps of the passed transactions.
+ * @param oldDoc The Prosemirror node to start from
+ * @param transactions The transactions to combine
+ * @returns A new `Transform` with all steps of the passed transactions
+ */
+declare function combineTransactionSteps(oldDoc: Node$1, transactions: Transaction[]): Transform;
+
+/**
+ * Takes a Transaction & Editor State and turns it into a chainable state object
+ * @param config The transaction and state to create the chainable state from
+ * @returns A chainable Editor state object
+ */
+declare function createChainableState(config: {
+    transaction: Transaction;
+    state: EditorState;
+}): EditorState;
+
 type InputRuleMatch = {
     index: number;
     text: string;
@@ -206,7 +223,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: NodeType;
+            type: NodeType$1;
             parent: ParentConfig<NodeConfig<Options, Storage>>['addCommands'];
         }) => Partial<RawCommands>;
         /**
@@ -224,7 +241,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: NodeType;
+            type: NodeType$1;
             parent: ParentConfig<NodeConfig<Options, Storage>>['addKeyboardShortcuts'];
         }) => {
             [key: string]: KeyboardShortcutCommand;
@@ -247,7 +264,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: NodeType;
+            type: NodeType$1;
             parent: ParentConfig<NodeConfig<Options, Storage>>['addInputRules'];
         }) => InputRule[];
         /**
@@ -268,7 +285,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: NodeType;
+            type: NodeType$1;
             parent: ParentConfig<NodeConfig<Options, Storage>>['addPasteRules'];
         }) => PasteRule[];
         /**
@@ -286,7 +303,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: NodeType;
+            type: NodeType$1;
             parent: ParentConfig<NodeConfig<Options, Storage>>['addProseMirrorPlugins'];
         }) => Plugin[];
         /**
@@ -348,7 +365,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: NodeType;
+            type: NodeType$1;
             parent: ParentConfig<NodeConfig<Options, Storage>>['onBeforeCreate'];
         }) => void) | null;
         /**
@@ -359,7 +376,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: NodeType;
+            type: NodeType$1;
             parent: ParentConfig<NodeConfig<Options, Storage>>['onCreate'];
         }) => void) | null;
         /**
@@ -370,7 +387,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: NodeType;
+            type: NodeType$1;
             parent: ParentConfig<NodeConfig<Options, Storage>>['onUpdate'];
         }) => void) | null;
         /**
@@ -381,7 +398,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: NodeType;
+            type: NodeType$1;
             parent: ParentConfig<NodeConfig<Options, Storage>>['onSelectionUpdate'];
         }) => void) | null;
         /**
@@ -392,7 +409,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: NodeType;
+            type: NodeType$1;
             parent: ParentConfig<NodeConfig<Options, Storage>>['onTransaction'];
         }, props: {
             editor: Editor;
@@ -406,7 +423,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: NodeType;
+            type: NodeType$1;
             parent: ParentConfig<NodeConfig<Options, Storage>>['onFocus'];
         }, props: {
             event: FocusEvent;
@@ -419,7 +436,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: NodeType;
+            type: NodeType$1;
             parent: ParentConfig<NodeConfig<Options, Storage>>['onBlur'];
         }, props: {
             event: FocusEvent;
@@ -432,7 +449,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: NodeType;
+            type: NodeType$1;
             parent: ParentConfig<NodeConfig<Options, Storage>>['onDestroy'];
         }) => void) | null;
         /**
@@ -443,7 +460,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: NodeType;
+            type: NodeType$1;
             parent: ParentConfig<NodeConfig<Options, Storage>>['addNodeView'];
         }) => NodeViewRenderer) | null;
         /**
@@ -827,7 +844,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: MarkType;
+            type: MarkType$1;
             parent: ParentConfig<MarkConfig<Options, Storage>>['addCommands'];
         }) => Partial<RawCommands>;
         /**
@@ -845,7 +862,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: MarkType;
+            type: MarkType$1;
             parent: ParentConfig<MarkConfig<Options, Storage>>['addKeyboardShortcuts'];
         }) => {
             [key: string]: KeyboardShortcutCommand;
@@ -868,7 +885,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: MarkType;
+            type: MarkType$1;
             parent: ParentConfig<MarkConfig<Options, Storage>>['addInputRules'];
         }) => InputRule[];
         /**
@@ -889,7 +906,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: MarkType;
+            type: MarkType$1;
             parent: ParentConfig<MarkConfig<Options, Storage>>['addPasteRules'];
         }) => PasteRule[];
         /**
@@ -907,7 +924,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: MarkType;
+            type: MarkType$1;
             parent: ParentConfig<MarkConfig<Options, Storage>>['addProseMirrorPlugins'];
         }) => Plugin[];
         /**
@@ -968,7 +985,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: MarkType;
+            type: MarkType$1;
             parent: ParentConfig<MarkConfig<Options, Storage>>['onBeforeCreate'];
         }) => void) | null;
         /**
@@ -979,7 +996,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: MarkType;
+            type: MarkType$1;
             parent: ParentConfig<MarkConfig<Options, Storage>>['onCreate'];
         }) => void) | null;
         /**
@@ -990,7 +1007,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: MarkType;
+            type: MarkType$1;
             parent: ParentConfig<MarkConfig<Options, Storage>>['onUpdate'];
         }) => void) | null;
         /**
@@ -1001,7 +1018,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: MarkType;
+            type: MarkType$1;
             parent: ParentConfig<MarkConfig<Options, Storage>>['onSelectionUpdate'];
         }) => void) | null;
         /**
@@ -1012,7 +1029,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: MarkType;
+            type: MarkType$1;
             parent: ParentConfig<MarkConfig<Options, Storage>>['onTransaction'];
         }, props: {
             editor: Editor;
@@ -1026,7 +1043,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: MarkType;
+            type: MarkType$1;
             parent: ParentConfig<MarkConfig<Options, Storage>>['onFocus'];
         }, props: {
             event: FocusEvent;
@@ -1039,7 +1056,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: MarkType;
+            type: MarkType$1;
             parent: ParentConfig<MarkConfig<Options, Storage>>['onBlur'];
         }, props: {
             event: FocusEvent;
@@ -1052,7 +1069,7 @@ declare module '@tiptap/core' {
             options: Options;
             storage: Storage;
             editor: Editor;
-            type: MarkType;
+            type: MarkType$1;
             parent: ParentConfig<MarkConfig<Options, Storage>>['onDestroy'];
         }) => void) | null;
         /**
@@ -1536,6 +1553,7 @@ interface EditorEvents {
     update: {
         editor: Editor;
         transaction: Transaction;
+        appendedTransactions: Transaction[];
     };
     selectionUpdate: {
         editor: Editor;
@@ -1549,6 +1567,7 @@ interface EditorEvents {
     transaction: {
         editor: Editor;
         transaction: Transaction;
+        appendedTransactions: Transaction[];
     };
     focus: {
         editor: Editor;
@@ -1645,6 +1664,45 @@ type JSONContent = {
     text?: string;
     [key: string]: any;
 };
+/**
+ * A mark type is either a JSON representation of a mark or a Prosemirror mark instance
+ */
+type MarkType<Type extends string | {
+    name: string;
+} = any, Attributes extends undefined | Record<string, any> = any> = {
+    type: Type;
+    attrs: Attributes;
+};
+/**
+ * A node type is either a JSON representation of a node or a Prosemirror node instance
+ */
+type NodeType<Type extends string | {
+    name: string;
+} = any, Attributes extends undefined | Record<string, any> = any, NodeMarkType extends MarkType = any, Content extends (NodeType | TextType)[] = any> = {
+    type: Type;
+    attrs: Attributes;
+    content?: Content;
+    marks?: NodeMarkType[];
+};
+/**
+ * A node type is either a JSON representation of a doc node or a Prosemirror doc node instance
+ */
+type DocumentType<TDocAttributes extends Record<string, any> | undefined = Record<string, any>, TContentType extends NodeType[] = NodeType[]> = Omit<NodeType<'doc', TDocAttributes, never, TContentType>, 'marks' | 'content'> & {
+    content: TContentType;
+};
+/**
+ * A node type is either a JSON representation of a text node or a Prosemirror text node instance
+ */
+type TextType<TMarkType extends MarkType = MarkType> = {
+    type: 'text';
+    text: string;
+    marks: TMarkType[];
+};
+/**
+ * Describes the output of a `renderHTML` function in prosemirror
+ * @see https://prosemirror.net/docs/ref/#model.DOMOutputSpec
+ */
+type DOMOutputSpecArray = [string] | [string, Record<string, any>] | [string, 0] | [string, Record<string, any>, 0] | [string, Record<string, any>, DOMOutputSpecArray | 0] | [string, DOMOutputSpecArray];
 type Content = HTMLContent | JSONContent | JSONContent[] | null;
 type CommandProps = {
     editor: Editor;
@@ -1663,6 +1721,7 @@ type KeyboardShortcutCommand = (props: {
 }) => boolean;
 type Attribute = {
     default?: any;
+    validate?: string | ((value: any) => void);
     rendered?: boolean;
     renderHTML?: ((attributes: Record<string, any>) => Record<string, any> | null) | null;
     parseHTML?: ((element: HTMLElement) => any | null) | null;
@@ -1675,7 +1734,7 @@ type Attributes = {
 type ExtensionAttribute = {
     type: string;
     name: string;
-    attribute: Required<Attribute>;
+    attribute: Required<Omit<Attribute, 'validate'>> & Pick<Attribute, 'validate'>;
 };
 type GlobalAttributes = {
     /**
@@ -1774,7 +1833,7 @@ interface NodeViewRendererProps {
 }
 type NodeViewRenderer = (props: NodeViewRendererProps) => NodeView$1;
 type AnyCommands = Record<string, (...args: any[]) => Command>;
-type UnionCommands<T = Command> = UnionToIntersection<ValuesOf<Pick<Commands<T>, KeysWithTypeOf<Commands<T>, {}>>>>;
+type UnionCommands<T = Command> = UnionToIntersection<ValuesOf<Pick<Commands<T>, KeysWithTypeOf<Commands<T>, object>>>>;
 type RawCommands = {
     [Item in keyof UnionCommands]: UnionCommands<Command>[Item];
 };
@@ -1821,849 +1880,728 @@ type ExtendedRegExpMatchArray = RegExpMatchArray & {
 };
 type Dispatch = ((args?: any) => any) | undefined;
 
-declare class ExtensionManager {
-    editor: Editor;
-    schema: Schema;
-    extensions: Extensions;
-    splittableMarks: string[];
-    constructor(extensions: Extensions, editor: Editor);
-    /**
-     * Returns a flattened and sorted extension list while
-     * also checking for duplicated extensions and warns the user.
-     * @param extensions An array of Tiptap extensions
-     * @returns An flattened and sorted array of Tiptap extensions
-     */
-    static resolve(extensions: Extensions): Extensions;
-    /**
-     * Create a flattened array of extensions by traversing the `addExtensions` field.
-     * @param extensions An array of Tiptap extensions
-     * @returns A flattened array of Tiptap extensions
-     */
-    static flatten(extensions: Extensions): Extensions;
-    /**
-     * Sort extensions by priority.
-     * @param extensions An array of Tiptap extensions
-     * @returns A sorted array of Tiptap extensions by priority
-     */
-    static sort(extensions: Extensions): Extensions;
-    /**
-     * Get all commands from the extensions.
-     * @returns An object with all commands where the key is the command name and the value is the command function
-     */
-    get commands(): RawCommands;
-    /**
-     * Get all registered Prosemirror plugins from the extensions.
-     * @returns An array of Prosemirror plugins
-     */
-    get plugins(): Plugin[];
-    /**
-     * Get all attributes from the extensions.
-     * @returns An array of attributes
-     */
-    get attributes(): ExtensionAttribute[];
-    /**
-     * Get all node views from the extensions.
-     * @returns An object with all node views where the key is the node name and the value is the node view function
-     */
-    get nodeViews(): Record<string, NodeViewConstructor>;
-    /**
-     * Go through all extensions, create extension storages & setup marks
-     * & bind editor event listener.
-     */
-    private setupExtensions;
-}
-
-declare class NodePos {
-    private resolvedPos;
-    private isBlock;
-    private editor;
-    private get name();
-    constructor(pos: ResolvedPos, editor: Editor, isBlock?: boolean, node?: Node$1 | null);
-    private currentNode;
-    get node(): Node$1;
-    get element(): HTMLElement;
-    actualDepth: number | null;
-    get depth(): number;
-    get pos(): number;
-    get content(): Fragment;
-    set content(content: Content);
-    get attributes(): {
-        [key: string]: any;
-    };
-    get textContent(): string;
-    get size(): number;
-    get from(): number;
-    get range(): Range;
-    get to(): number;
-    get parent(): NodePos | null;
-    get before(): NodePos | null;
-    get after(): NodePos | null;
-    get children(): NodePos[];
-    get firstChild(): NodePos | null;
-    get lastChild(): NodePos | null;
-    closest(selector: string, attributes?: {
-        [key: string]: any;
-    }): NodePos | null;
-    querySelector(selector: string, attributes?: {
-        [key: string]: any;
-    }): NodePos | null;
-    querySelectorAll(selector: string, attributes?: {
-        [key: string]: any;
-    }, firstItemOnly?: boolean): NodePos[];
-    setAttribute(attributes: {
-        [key: string]: any;
-    }): void;
-}
+/**
+ * Create a new Prosemirror document node from content.
+ * @param content The JSON or HTML content to create the document from
+ * @param schema The Prosemirror schema to use for the document
+ * @param parseOptions Options for the parser
+ * @returns The created Prosemirror document node
+ */
+declare function createDocument(content: Content | Node$1 | Fragment, schema: Schema, parseOptions?: ParseOptions, options?: {
+    errorOnInvalidContent?: boolean;
+}): Node$1;
 
-type ClipboardTextSerializerOptions = {
-    blockSeparator?: string;
+type CreateNodeFromContentOptions = {
+    slice?: boolean;
+    parseOptions?: ParseOptions;
+    errorOnInvalidContent?: boolean;
 };
-declare const ClipboardTextSerializer: Extension<ClipboardTextSerializerOptions, any>;
+/**
+ * Takes a JSON or HTML content and creates a Prosemirror node or fragment from it.
+ * @param content The JSON or HTML content to create the node from
+ * @param schema The Prosemirror schema to use for the node
+ * @param options Options for the parser
+ * @returns The created Prosemirror node or fragment
+ */
+declare function createNodeFromContent(content: Content | Node$1 | Fragment, schema: Schema, options?: CreateNodeFromContentOptions): Node$1 | Fragment;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        blur: {
-            /**
-             * Removes focus from the editor.
-             * @example editor.commands.blur()
-             */
-            blur: () => ReturnType;
-        };
-    }
-}
+/**
+ * Gets the default block type at a given match
+ * @param match The content match to get the default block type from
+ * @returns The default block type or null
+ */
+declare function defaultBlockAt(match: ContentMatch): NodeType$1 | null;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        clearContent: {
-            /**
-             * Clear the whole document.
-             * @param emitUpdate Whether to emit an update event.
-             * @example editor.commands.clearContent()
-             */
-            clearContent: (emitUpdate?: boolean) => ReturnType;
-        };
-    }
-}
+/**
+ * Find children inside a Prosemirror node that match a predicate.
+ * @param node The Prosemirror node to search in
+ * @param predicate The predicate to match
+ * @returns An array of nodes with their positions
+ */
+declare function findChildren(node: Node$1, predicate: Predicate): NodeWithPos[];
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        clearNodes: {
-            /**
-             * Normalize nodes to a simple paragraph.
-             * @example editor.commands.clearNodes()
-             */
-            clearNodes: () => ReturnType;
-        };
-    }
-}
+/**
+ * Same as `findChildren` but searches only within a `range`.
+ * @param node The Prosemirror node to search in
+ * @param range The range to search in
+ * @param predicate The predicate to match
+ * @returns An array of nodes with their positions
+ */
+declare function findChildrenInRange(node: Node$1, range: Range, predicate: Predicate): NodeWithPos[];
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        command: {
-            /**
-             * Define a command inline.
-             * @param fn The command function.
-             * @example
-             * editor.commands.command(({ tr, state }) => {
-             *   ...
-             *   return true
-             * })
-             */
-            command: (fn: (props: Parameters<Command>[0]) => boolean) => ReturnType;
-        };
-    }
-}
+/**
+ * Finds the closest parent node to a resolved position that matches a predicate.
+ * @param $pos The resolved position to search from
+ * @param predicate The predicate to match
+ * @returns The closest parent node to the resolved position that matches the predicate
+ * @example ```js
+ * findParentNodeClosestToPos($from, node => node.type.name === 'paragraph')
+ * ```
+ */
+declare function findParentNodeClosestToPos($pos: ResolvedPos, predicate: Predicate): {
+    pos: number;
+    start: number;
+    depth: number;
+    node: Node$1;
+} | undefined;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        createParagraphNear: {
-            /**
-             * Create a paragraph nearby.
-             * @example editor.commands.createParagraphNear()
-             */
-            createParagraphNear: () => ReturnType;
-        };
-    }
-}
+/**
+ * Finds the closest parent node to the current selection that matches a predicate.
+ * @param predicate The predicate to match
+ * @returns A command that finds the closest parent node to the current selection that matches the predicate
+ * @example ```js
+ * findParentNode(node => node.type.name === 'paragraph')
+ * ```
+ */
+declare function findParentNode(predicate: Predicate): (selection: Selection) => ReturnType<typeof findParentNodeClosestToPos>;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        cut: {
-            /**
-             * Cuts content from a range and inserts it at a given position.
-             * @param range The range to cut.
-             * @param range.from The start position of the range.
-             * @param range.to The end position of the range.
-             * @param targetPos The position to insert the content at.
-             * @example editor.commands.cut({ from: 1, to: 3 }, 5)
-             */
-            cut: ({ from, to }: {
-                from: number;
-                to: number;
-            }, targetPos: number) => ReturnType;
-        };
-    }
-}
+/**
+ * Create a flattened array of extensions by traversing the `addExtensions` field.
+ * @param extensions An array of Tiptap extensions
+ * @returns A flattened array of Tiptap extensions
+ */
+declare function flattenExtensions(extensions: Extensions): Extensions;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        deleteCurrentNode: {
-            /**
-             * Delete the node that currently has the selection anchor.
-             * @example editor.commands.deleteCurrentNode()
-             */
-            deleteCurrentNode: () => ReturnType;
-        };
-    }
-}
+/**
+ * Generate HTML from a JSONContent
+ * @param doc The JSONContent to generate HTML from
+ * @param extensions The extensions to use for the schema
+ * @returns The generated HTML
+ */
+declare function generateHTML(doc: JSONContent, extensions: Extensions): string;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        deleteNode: {
-            /**
-             * Delete a node with a given type or name.
-             * @param typeOrName The type or name of the node.
-             * @example editor.commands.deleteNode('paragraph')
-             */
-            deleteNode: (typeOrName: string | NodeType) => ReturnType;
-        };
-    }
-}
+/**
+ * Generate JSONContent from HTML
+ * @param html The HTML to generate JSONContent from
+ * @param extensions The extensions to use for the schema
+ * @returns The generated JSONContent
+ */
+declare function generateJSON(html: string, extensions: Extensions): Record<string, any>;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        deleteRange: {
-            /**
-             * Delete a given range.
-             * @param range The range to delete.
-             * @example editor.commands.deleteRange({ from: 1, to: 3 })
-             */
-            deleteRange: (range: Range) => ReturnType;
-        };
-    }
-}
+/**
+ * Generate raw text from a JSONContent
+ * @param doc The JSONContent to generate text from
+ * @param extensions The extensions to use for the schema
+ * @param options Options for the text generation f.e. blockSeparator or textSerializers
+ * @returns The generated text
+ */
+declare function generateText(doc: JSONContent, extensions: Extensions, options?: {
+    blockSeparator?: string;
+    textSerializers?: Record<string, TextSerializer>;
+}): string;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        deleteSelection: {
-            /**
-             * Delete the selection, if there is one.
-             * @example editor.commands.deleteSelection()
-             */
-            deleteSelection: () => ReturnType;
-        };
-    }
-}
+/**
+ * Get node or mark attributes by type or name on the current editor state
+ * @param state The current editor state
+ * @param typeOrName The node or mark type or name
+ * @returns The attributes of the node or mark or an empty object
+ */
+declare function getAttributes(state: EditorState, typeOrName: string | NodeType$1 | MarkType$1): Record<string, any>;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        enter: {
-            /**
-             * Trigger enter.
-             * @example editor.commands.enter()
-             */
-            enter: () => ReturnType;
-        };
-    }
-}
+/**
+ * Get a list of all extension attributes defined in `addAttribute` and `addGlobalAttribute`.
+ * @param extensions List of extensions
+ */
+declare function getAttributesFromExtensions(extensions: Extensions): ExtensionAttribute[];
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        exitCode: {
-            /**
-             * Exit from a code block.
-             * @example editor.commands.exitCode()
-             */
-            exitCode: () => ReturnType;
-        };
-    }
-}
+type ChangedRange = {
+    oldRange: Range;
+    newRange: Range;
+};
+/**
+ * Returns a list of changed ranges
+ * based on the first and last state of all steps.
+ */
+declare function getChangedRanges(transform: Transform): ChangedRange[];
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        extendMarkRange: {
-            /**
-             * Extends the text selection to the current mark by type or name.
-             * @param typeOrName The type or name of the mark.
-             * @param attributes The attributes of the mark.
-             * @example editor.commands.extendMarkRange('bold')
-             * @example editor.commands.extendMarkRange('mention', { userId: "1" })
-             */
-            extendMarkRange: (
-            /**
-             * The type or name of the mark.
-             */
-            typeOrName: string | MarkType, 
-            /**
-             * The attributes of the mark.
-             */
-            attributes?: Record<string, any>) => ReturnType;
-        };
-    }
+interface DebugJSONContent extends JSONContent {
+    from: number;
+    to: number;
 }
+declare function getDebugJSON(node: Node$1, startOffset?: number): DebugJSONContent;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        first: {
-            /**
-             * Runs one command after the other and stops at the first which returns true.
-             * @param commands The commands to run.
-             * @example editor.commands.first([command1, command2])
-             */
-            first: (commands: Command[] | ((props: CommandProps) => Command[])) => ReturnType;
-        };
-    }
-}
+/**
+ * Returns a field from an extension
+ * @param extension The Tiptap extension
+ * @param field The field, for example `renderHTML` or `priority`
+ * @param context The context object that should be passed as `this` into the function
+ * @returns The field value
+ */
+declare function getExtensionField<T = any>(extension: AnyExtension, field: string, context?: Omit<MaybeThisParameterType<T>, 'parent'>): RemoveThis<T>;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        focus: {
-            /**
-             * Focus the editor at the given position.
-             * @param position The position to focus at.
-             * @param options.scrollIntoView Scroll the focused position into view after focusing
-             * @example editor.commands.focus()
-             * @example editor.commands.focus(32, { scrollIntoView: false })
-             */
-            focus: (
-            /**
-             * The position to focus at.
-             */
-            position?: FocusPosition, 
-            /**
-             * Optional options
-             * @default { scrollIntoView: true }
-             */
-            options?: {
-                scrollIntoView?: boolean;
-            }) => ReturnType;
-        };
-    }
-}
+declare function getHTMLFromFragment(fragment: Fragment, schema: Schema): string;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        forEach: {
-            /**
-             * Loop through an array of items.
-             */
-            forEach: <T>(items: T[], fn: (item: T, props: CommandProps & {
-                index: number;
-            }) => boolean) => ReturnType;
-        };
-    }
-}
+declare function getMarkAttributes(state: EditorState, typeOrName: string | MarkType$1): Record<string, any>;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        insertContent: {
-            /**
-             * Insert a node or string of HTML at the current position.
-             * @example editor.commands.insertContent('<h1>Example</h1>')
-             * @example editor.commands.insertContent('<h1>Example</h1>', { updateSelection: false })
-             */
-            insertContent: (
-            /**
-             * The ProseMirror content to insert.
-             */
-            value: Content | Node$1 | Fragment, 
-            /**
-             * Optional options
-             */
-            options?: {
-                /**
-                 * Options for parsing the content.
-                 */
-                parseOptions?: ParseOptions;
-                /**
-                 * Whether to update the selection after inserting the content.
-                 */
-                updateSelection?: boolean;
-                applyInputRules?: boolean;
-                applyPasteRules?: boolean;
-            }) => ReturnType;
-        };
-    }
-}
+/**
+ * Get the range of a mark at a resolved position.
+ */
+declare function getMarkRange(
+/**
+ * The position to get the mark range for.
+ */
+$pos: ResolvedPos, 
+/**
+ * The mark type to get the range for.
+ */
+type: MarkType$1, 
+/**
+ * The attributes to match against.
+ * If not provided, only the first mark at the position will be matched.
+ */
+attributes?: Record<string, any>): Range | void;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        insertContentAt: {
-            /**
-             * Insert a node or string of HTML at a specific position.
-             * @example editor.commands.insertContentAt(0, '<h1>Example</h1>')
-             */
-            insertContentAt: (
-            /**
-             * The position to insert the content at.
-             */
-            position: number | Range, 
-            /**
-             * The ProseMirror content to insert.
-             */
-            value: Content | Node$1 | Fragment, 
-            /**
-             * Optional options
-             */
-            options?: {
-                /**
-                 * Options for parsing the content.
-                 */
-                parseOptions?: ParseOptions;
-                /**
-                 * Whether to update the selection after inserting the content.
-                 */
-                updateSelection?: boolean;
-                /**
-                 * Whether to apply input rules after inserting the content.
-                 */
-                applyInputRules?: boolean;
-                /**
-                 * Whether to apply paste rules after inserting the content.
-                 */
-                applyPasteRules?: boolean;
-                /**
-                 * Whether to throw an error if the content is invalid.
-                 */
-                errorOnInvalidContent?: boolean;
-            }) => ReturnType;
-        };
-    }
-}
-
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        joinUp: {
-            /**
-             * Join the selected block or, if there is a text selection, the closest ancestor block of the selection that can be joined, with the sibling above it.
-             * @example editor.commands.joinUp()
-             */
-            joinUp: () => ReturnType;
-        };
-        joinDown: {
-            /**
-             * Join the selected block, or the closest ancestor of the selection that can be joined, with the sibling after it.
-             * @example editor.commands.joinDown()
-             */
-            joinDown: () => ReturnType;
-        };
-        joinBackward: {
-            /**
-             * If the selection is empty and at the start of a textblock, try to reduce the distance between that block and the one before it—if there's a block directly before it that can be joined, join them.
-             * If not, try to move the selected block closer to the next one in the document structure by lifting it out of its
-             * parent or moving it into a parent of the previous block. Will use the view for accurate (bidi-aware) start-of-textblock detection if given.
-             * @example editor.commands.joinBackward()
-             */
-            joinBackward: () => ReturnType;
-        };
-        joinForward: {
-            /**
-             * If the selection is empty and the cursor is at the end of a textblock, try to reduce or remove the boundary between that block and the one after it,
-             * either by joining them or by moving the other block closer to this one in the tree structure.
-             * Will use the view for accurate start-of-textblock detection if given.
-             * @example editor.commands.joinForward()
-             */
-            joinForward: () => ReturnType;
-        };
-    }
-}
+declare function getMarksBetween(from: number, to: number, doc: Node$1): MarkRange[];
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        joinItemBackward: {
-            /**
-             * Join two items backward.
-             * @example editor.commands.joinItemBackward()
-             */
-            joinItemBackward: () => ReturnType;
-        };
-    }
-}
+declare function getMarkType(nameOrType: string | MarkType$1, schema: Schema): MarkType$1;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        joinItemForward: {
-            /**
-             * Join two items Forwards.
-             * @example editor.commands.joinItemForward()
-             */
-            joinItemForward: () => ReturnType;
-        };
-    }
-}
+/**
+ * Finds the first node of a given type or name in the current selection.
+ * @param state The editor state.
+ * @param typeOrName The node type or name.
+ * @param pos The position to start searching from.
+ * @param maxDepth The maximum depth to search.
+ * @returns The node and the depth as an array.
+ */
+declare const getNodeAtPosition: (state: EditorState, typeOrName: string | NodeType$1, pos: number, maxDepth?: number) => [Node$1 | null, number];
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        joinTextblockBackward: {
-            /**
-             * A more limited form of joinBackward that only tries to join the current textblock to the one before it, if the cursor is at the start of a textblock.
-             */
-            joinTextblockBackward: () => ReturnType;
-        };
-    }
-}
+declare function getNodeAttributes(state: EditorState, typeOrName: string | NodeType$1): Record<string, any>;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        joinTextblockForward: {
-            /**
-             * A more limited form of joinForward that only tries to join the current textblock to the one after it, if the cursor is at the end of a textblock.
-             */
-            joinTextblockForward: () => ReturnType;
-        };
-    }
-}
+declare function getNodeType(nameOrType: string | NodeType$1, schema: Schema): NodeType$1;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        keyboardShortcut: {
-            /**
-             * Trigger a keyboard shortcut.
-             * @param name The name of the keyboard shortcut.
-             * @example editor.commands.keyboardShortcut('Mod-b')
-             */
-            keyboardShortcut: (name: string) => ReturnType;
-        };
-    }
-}
+declare function getRenderedAttributes(nodeOrMark: Node$1 | Mark$1, extensionAttributes: ExtensionAttribute[]): Record<string, any>;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        lift: {
-            /**
-             * Removes an existing wrap if possible lifting the node out of it
-             * @param typeOrName The type or name of the node.
-             * @param attributes The attributes of the node.
-             * @example editor.commands.lift('paragraph')
-             * @example editor.commands.lift('heading', { level: 1 })
-             */
-            lift: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType;
-        };
-    }
-}
+declare function getSchema(extensions: Extensions, editor?: Editor): Schema;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        liftEmptyBlock: {
-            /**
-             * If the cursor is in an empty textblock that can be lifted, lift the block.
-             * @example editor.commands.liftEmptyBlock()
-             */
-            liftEmptyBlock: () => ReturnType;
-        };
-    }
-}
+/**
+ * Creates a new Prosemirror schema based on the given extensions.
+ * @param extensions An array of Tiptap extensions
+ * @param editor The editor instance
+ * @returns A Prosemirror schema
+ */
+declare function getSchemaByResolvedExtensions(extensions: Extensions, editor?: Editor): Schema;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        liftListItem: {
-            /**
-             * Create a command to lift the list item around the selection up into a wrapping list.
-             * @param typeOrName The type or name of the node.
-             * @example editor.commands.liftListItem('listItem')
-             */
-            liftListItem: (typeOrName: string | NodeType) => ReturnType;
-        };
-    }
-}
+/**
+ * Tries to get a node or mark type by its name.
+ * @param name The name of the node or mark type
+ * @param schema The Prosemiror schema to search in
+ * @returns The node or mark type, or null if it doesn't exist
+ */
+declare function getSchemaTypeByName(name: string, schema: Schema): NodeType$1 | MarkType$1 | null;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        newlineInCode: {
-            /**
-             * Add a newline character in code.
-             * @example editor.commands.newlineInCode()
-             */
-            newlineInCode: () => ReturnType;
-        };
-    }
-}
+/**
+ * Get the type of a schema item by its name.
+ * @param name The name of the schema item
+ * @param schema The Prosemiror schema to search in
+ * @returns The type of the schema item (`node` or `mark`), or null if it doesn't exist
+ */
+declare function getSchemaTypeNameByName(name: string, schema: Schema): 'node' | 'mark' | null;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        resetAttributes: {
-            /**
-             * Resets some node attributes to the default value.
-             * @param typeOrName The type or name of the node.
-             * @param attributes The attributes of the node to reset.
-             * @example editor.commands.resetAttributes('heading', 'level')
-             */
-            resetAttributes: (typeOrName: string | NodeType | MarkType, attributes: string | string[]) => ReturnType;
-        };
-    }
-}
+/**
+ * Return attributes of an extension that should be splitted by keepOnSplit flag
+ * @param extensionAttributes Array of extension attributes
+ * @param typeName The type of the extension
+ * @param attributes The attributes of the extension
+ * @returns The splitted attributes
+ */
+declare function getSplittedAttributes(extensionAttributes: ExtensionAttribute[], typeName: string, attributes: Record<string, any>): Record<string, any>;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        scrollIntoView: {
-            /**
-             * Scroll the selection into view.
-             * @example editor.commands.scrollIntoView()
-             */
-            scrollIntoView: () => ReturnType;
-        };
-    }
-}
+/**
+ * Gets the text of a Prosemirror node
+ * @param node The Prosemirror node
+ * @param options Options for the text serializer & block separator
+ * @returns The text of the node
+ * @example ```js
+ * const text = getText(node, { blockSeparator: '\n' })
+ * ```
+ */
+declare function getText(node: Node$1, options?: {
+    blockSeparator?: string;
+    textSerializers?: Record<string, TextSerializer>;
+}): string;
 
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        selectAll: {
-            /**
-             * Select the whole document.
-             * @example editor.commands.selectAll()
+/**
+ * Gets the text between two positions in a Prosemirror node
+ * and serializes it using the given text serializers and block separator (see getText)
+ * @param startNode The Prosemirror node to start from
+ * @param range The range of the text to get
+ * @param options Options for the text serializer & block separator
+ * @returns The text between the two positions
+ */
+declare function getTextBetween(startNode: Node$1, range: Range, options?: {
+    blockSeparator?: string;
+    textSerializers?: Record<string, TextSerializer>;
+}): string;
+
+/**
+ * Returns the text content of a resolved prosemirror position
+ * @param $from The resolved position to get the text content from
+ * @param maxMatch The maximum number of characters to match
+ * @returns The text content
+ */
+declare const getTextContentFromNodes: ($from: ResolvedPos, maxMatch?: number) => string;
+
+/**
+ * Find text serializers `toText` in a Prosemirror schema
+ * @param schema The Prosemirror schema to search in
+ * @returns A record of text serializers by node name
+ */
+declare function getTextSerializersFromSchema(schema: Schema): Record<string, TextSerializer>;
+
+/**
+ * This function merges extension attributes into parserule attributes (`attrs` or `getAttrs`).
+ * Cancels when `getAttrs` returned `false`.
+ * @param parseRule ProseMirror ParseRule
+ * @param extensionAttributes List of attributes to inject
+ */
+declare function injectExtensionAttributesToParseRule(parseRule: ParseRule, extensionAttributes: ExtensionAttribute[]): ParseRule;
+
+declare function isActive(state: EditorState, name: string | null, attributes?: Record<string, any>): boolean;
+
+declare const isAtEndOfNode: (state: EditorState, nodeType?: string) => boolean;
+
+declare const isAtStartOfNode: (state: EditorState) => boolean;
+
+declare function isExtensionRulesEnabled(extension: AnyExtension, enabled: EnableRules): boolean;
+
+declare function isList(name: string, extensions: Extensions): boolean;
+
+declare function isMarkActive(state: EditorState, typeOrName: MarkType$1 | string | null, attributes?: Record<string, any>): boolean;
+
+declare function isNodeActive(state: EditorState, typeOrName: NodeType$1 | string | null, attributes?: Record<string, any>): boolean;
+
+/**
+ * Returns true if the given prosemirror node is empty.
+ */
+declare function isNodeEmpty(node: Node$1, { checkChildren, ignoreWhitespace, }?: {
+    /**
+     * When true (default), it will also check if all children are empty.
+     */
+    checkChildren?: boolean;
+    /**
+     * When true, it will ignore whitespace when checking for emptiness.
+     */
+    ignoreWhitespace?: boolean;
+}): boolean;
+
+declare function isNodeSelection(value: unknown): value is NodeSelection;
+
+declare function isTextSelection(value: unknown): value is TextSelection;
+
+declare function posToDOMRect(view: EditorView, from: number, to: number): DOMRect;
+
+/**
+ * Returns a flattened and sorted extension list while
+ * also checking for duplicated extensions and warns the user.
+ * @param extensions An array of Tiptap extensions
+ * @returns An flattened and sorted array of Tiptap extensions
+ */
+declare function resolveExtensions(extensions: Extensions): Extensions;
+
+declare function resolveFocusPosition(doc: Node$1, position?: FocusPosition): Selection | null;
+
+type RewriteUnknownContentOptions = {
+    /**
+     * If true, unknown nodes will be treated as paragraphs
+     * @default true
+     */
+    fallbackToParagraph?: boolean;
+};
+/**
+ * Rewrite unknown nodes and marks within JSON content
+ * Allowing for user within the editor
+ */
+declare function rewriteUnknownContent(
+/**
+ * The JSON content to clean of unknown nodes and marks
+ */
+json: JSONContent, 
+/**
+ * The schema to use for validation
+ */
+schema: Schema, 
+/**
+ * Options for the cleaning process
+ */
+options?: RewriteUnknownContentOptions): {
+    /**
+     * The cleaned JSON content
+     */
+    json: JSONContent | null;
+    /**
+     * The array of nodes and marks that were rewritten
+     */
+    rewrittenContent: {
+        /**
+         * The original JSON content that was rewritten
+         */
+        original: JSONContent;
+        /**
+         * The name of the node or mark that was unsupported
+         */
+        unsupported: string;
+    }[];
+};
+
+declare function selectionToInsertionEnd(tr: Transaction, startLen: number, bias: number): void;
+
+/**
+ * Sort extensions by priority.
+ * @param extensions An array of Tiptap extensions
+ * @returns A sorted array of Tiptap extensions by priority
+ */
+declare function sortExtensions(extensions: Extensions): Extensions;
+
+declare function splitExtensions(extensions: Extensions): {
+    baseExtensions: Extension<any, any>[];
+    nodeExtensions: Node<any, any>[];
+    markExtensions: Mark<any, any>[];
+};
+
+declare class ExtensionManager {
+    editor: Editor;
+    schema: Schema;
+    extensions: Extensions;
+    splittableMarks: string[];
+    constructor(extensions: Extensions, editor: Editor);
+    static resolve: typeof resolveExtensions;
+    static sort: typeof sortExtensions;
+    static flatten: typeof flattenExtensions;
+    /**
+     * Get all commands from the extensions.
+     * @returns An object with all commands where the key is the command name and the value is the command function
+     */
+    get commands(): RawCommands;
+    /**
+     * Get all registered Prosemirror plugins from the extensions.
+     * @returns An array of Prosemirror plugins
+     */
+    get plugins(): Plugin[];
+    /**
+     * Get all attributes from the extensions.
+     * @returns An array of attributes
+     */
+    get attributes(): ExtensionAttribute[];
+    /**
+     * Get all node views from the extensions.
+     * @returns An object with all node views where the key is the node name and the value is the node view function
+     */
+    get nodeViews(): Record<string, NodeViewConstructor>;
+    /**
+     * Go through all extensions, create extension storages & setup marks
+     * & bind editor event listener.
+     */
+    private setupExtensions;
+}
+
+declare class NodePos {
+    private resolvedPos;
+    private isBlock;
+    private editor;
+    private get name();
+    constructor(pos: ResolvedPos, editor: Editor, isBlock?: boolean, node?: Node$1 | null);
+    private currentNode;
+    get node(): Node$1;
+    get element(): HTMLElement;
+    actualDepth: number | null;
+    get depth(): number;
+    get pos(): number;
+    get content(): Fragment;
+    set content(content: Content);
+    get attributes(): {
+        [key: string]: any;
+    };
+    get textContent(): string;
+    get size(): number;
+    get from(): number;
+    get range(): Range;
+    get to(): number;
+    get parent(): NodePos | null;
+    get before(): NodePos | null;
+    get after(): NodePos | null;
+    get children(): NodePos[];
+    get firstChild(): NodePos | null;
+    get lastChild(): NodePos | null;
+    closest(selector: string, attributes?: {
+        [key: string]: any;
+    }): NodePos | null;
+    querySelector(selector: string, attributes?: {
+        [key: string]: any;
+    }): NodePos | null;
+    querySelectorAll(selector: string, attributes?: {
+        [key: string]: any;
+    }, firstItemOnly?: boolean): NodePos[];
+    setAttribute(attributes: {
+        [key: string]: any;
+    }): void;
+}
+
+type ClipboardTextSerializerOptions = {
+    blockSeparator?: string;
+};
+declare const ClipboardTextSerializer: Extension<ClipboardTextSerializerOptions, any>;
+
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        blur: {
+            /**
+             * Removes focus from the editor.
+             * @example editor.commands.blur()
              */
-            selectAll: () => ReturnType;
+            blur: () => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        selectNodeBackward: {
+        clearContent: {
             /**
-             * Select a node backward.
-             * @example editor.commands.selectNodeBackward()
+             * Clear the whole document.
+             * @param emitUpdate Whether to emit an update event.
+             * @example editor.commands.clearContent()
              */
-            selectNodeBackward: () => ReturnType;
+            clearContent: (emitUpdate?: boolean) => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        selectNodeForward: {
+        clearNodes: {
             /**
-             * Select a node forward.
-             * @example editor.commands.selectNodeForward()
+             * Normalize nodes to a simple paragraph.
+             * @example editor.commands.clearNodes()
              */
-            selectNodeForward: () => ReturnType;
+            clearNodes: () => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        selectParentNode: {
+        command: {
             /**
-             * Select the parent node.
-             * @example editor.commands.selectParentNode()
+             * Define a command inline.
+             * @param fn The command function.
+             * @example
+             * editor.commands.command(({ tr, state }) => {
+             *   ...
+             *   return true
+             * })
              */
-            selectParentNode: () => ReturnType;
+            command: (fn: (props: Parameters<Command>[0]) => boolean) => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        selectTextblockEnd: {
+        createParagraphNear: {
             /**
-             * Moves the cursor to the end of current text block.
-             * @example editor.commands.selectTextblockEnd()
+             * Create a paragraph nearby.
+             * @example editor.commands.createParagraphNear()
              */
-            selectTextblockEnd: () => ReturnType;
+            createParagraphNear: () => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        selectTextblockStart: {
+        cut: {
             /**
-             * Moves the cursor to the start of current text block.
-             * @example editor.commands.selectTextblockStart()
+             * Cuts content from a range and inserts it at a given position.
+             * @param range The range to cut.
+             * @param range.from The start position of the range.
+             * @param range.to The end position of the range.
+             * @param targetPos The position to insert the content at.
+             * @example editor.commands.cut({ from: 1, to: 3 }, 5)
              */
-            selectTextblockStart: () => ReturnType;
+            cut: ({ from, to }: {
+                from: number;
+                to: number;
+            }, targetPos: number) => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        setContent: {
+        deleteCurrentNode: {
             /**
-             * Replace the whole document with new content.
-             * @param content The new content.
-             * @param emitUpdate Whether to emit an update event.
-             * @param parseOptions Options for parsing the content.
-             * @example editor.commands.setContent('<p>Example text</p>')
-             */
-            setContent: (
-            /**
-             * The new content.
-             */
-            content: Content | Fragment | Node$1, 
-            /**
-             * Whether to emit an update event.
-             * @default false
-             */
-            emitUpdate?: boolean, 
-            /**
-             * Options for parsing the content.
-             * @default {}
-             */
-            parseOptions?: ParseOptions, 
-            /**
-             * Options for `setContent`.
+             * Delete the node that currently has the selection anchor.
+             * @example editor.commands.deleteCurrentNode()
              */
-            options?: {
-                /**
-                 * Whether to throw an error if the content is invalid.
-                 */
-                errorOnInvalidContent?: boolean;
-            }) => ReturnType;
+            deleteCurrentNode: () => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        setMark: {
+        deleteNode: {
             /**
-             * Add a mark with new attributes.
-             * @param typeOrName The mark type or name.
-             * @example editor.commands.setMark('bold', { level: 1 })
+             * Delete a node with a given type or name.
+             * @param typeOrName The type or name of the node.
+             * @example editor.commands.deleteNode('paragraph')
              */
-            setMark: (typeOrName: string | MarkType, attributes?: Record<string, any>) => ReturnType;
+            deleteNode: (typeOrName: string | NodeType$1) => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        setMeta: {
+        deleteRange: {
             /**
-             * Store a metadata property in the current transaction.
-             * @param key The key of the metadata property.
-             * @param value The value to store.
-             * @example editor.commands.setMeta('foo', 'bar')
+             * Delete a given range.
+             * @param range The range to delete.
+             * @example editor.commands.deleteRange({ from: 1, to: 3 })
              */
-            setMeta: (key: string | Plugin | PluginKey, value: any) => ReturnType;
+            deleteRange: (range: Range) => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        setNode: {
+        deleteSelection: {
             /**
-             * Replace a given range with a node.
-             * @param typeOrName The type or name of the node
-             * @param attributes The attributes of the node
-             * @example editor.commands.setNode('paragraph')
+             * Delete the selection, if there is one.
+             * @example editor.commands.deleteSelection()
              */
-            setNode: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType;
+            deleteSelection: () => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        setNodeSelection: {
+        enter: {
             /**
-             * Creates a NodeSelection.
-             * @param position - Position of the node.
-             * @example editor.commands.setNodeSelection(10)
+             * Trigger enter.
+             * @example editor.commands.enter()
              */
-            setNodeSelection: (position: number) => ReturnType;
+            enter: () => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        setTextSelection: {
+        exitCode: {
             /**
-             * Creates a TextSelection.
-             * @param position The position of the selection.
-             * @example editor.commands.setTextSelection(10)
+             * Exit from a code block.
+             * @example editor.commands.exitCode()
              */
-            setTextSelection: (position: number | Range) => ReturnType;
+            exitCode: () => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        sinkListItem: {
+        extendMarkRange: {
             /**
-             * Sink the list item down into an inner list.
-             * @param typeOrName The type or name of the node.
-             * @example editor.commands.sinkListItem('listItem')
+             * Extends the text selection to the current mark by type or name.
+             * @param typeOrName The type or name of the mark.
+             * @param attributes The attributes of the mark.
+             * @example editor.commands.extendMarkRange('bold')
+             * @example editor.commands.extendMarkRange('mention', { userId: "1" })
+             */
+            extendMarkRange: (
+            /**
+             * The type or name of the mark.
              */
-            sinkListItem: (typeOrName: string | NodeType) => ReturnType;
+            typeOrName: string | MarkType$1, 
+            /**
+             * The attributes of the mark.
+             */
+            attributes?: Record<string, any>) => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        splitBlock: {
+        first: {
             /**
-             * Forks a new node from an existing node.
-             * @param options.keepMarks Keep marks from the previous node.
-             * @example editor.commands.splitBlock()
-             * @example editor.commands.splitBlock({ keepMarks: true })
+             * Runs one command after the other and stops at the first which returns true.
+             * @param commands The commands to run.
+             * @example editor.commands.first([command1, command2])
              */
-            splitBlock: (options?: {
-                keepMarks?: boolean;
-            }) => ReturnType;
+            first: (commands: Command[] | ((props: CommandProps) => Command[])) => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        splitListItem: {
+        focus: {
             /**
-             * Splits one list item into two list items.
-             * @param typeOrName The type or name of the node.
-             * @param overrideAttrs The attributes to ensure on the new node.
-             * @example editor.commands.splitListItem('listItem')
+             * Focus the editor at the given position.
+             * @param position The position to focus at.
+             * @param options.scrollIntoView Scroll the focused position into view after focusing
+             * @example editor.commands.focus()
+             * @example editor.commands.focus(32, { scrollIntoView: false })
+             */
+            focus: (
+            /**
+             * The position to focus at.
              */
-            splitListItem: (typeOrName: string | NodeType, overrideAttrs?: Record<string, any>) => ReturnType;
+            position?: FocusPosition, 
+            /**
+             * Optional options
+             * @default { scrollIntoView: true }
+             */
+            options?: {
+                scrollIntoView?: boolean;
+            }) => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        toggleList: {
+        forEach: {
             /**
-             * Toggle between different list types.
-             * @param listTypeOrName The type or name of the list.
-             * @param itemTypeOrName The type or name of the list item.
-             * @param keepMarks Keep marks when toggling.
-             * @param attributes Attributes for the new list.
-             * @example editor.commands.toggleList('bulletList', 'listItem')
+             * Loop through an array of items.
              */
-            toggleList: (listTypeOrName: string | NodeType, itemTypeOrName: string | NodeType, keepMarks?: boolean, attributes?: Record<string, any>) => ReturnType;
+            forEach: <T>(items: T[], fn: (item: T, props: CommandProps & {
+                index: number;
+            }) => boolean) => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        toggleMark: {
+        insertContent: {
             /**
-             * Toggle a mark on and off.
-             * @param typeOrName The mark type or name.
-             * @param attributes The attributes of the mark.
-             * @param options.extendEmptyMarkRange Removes the mark even across the current selection. Defaults to `false`.
-             * @example editor.commands.toggleMark('bold')
+             * Insert a node or string of HTML at the current position.
+             * @example editor.commands.insertContent('<h1>Example</h1>')
+             * @example editor.commands.insertContent('<h1>Example</h1>', { updateSelection: false })
              */
-            toggleMark: (
+            insertContent: (
             /**
-             * The mark type or name.
+             * The ProseMirror content to insert.
              */
-            typeOrName: string | MarkType, 
+            value: Content | Node$1 | Fragment, 
             /**
-             * The attributes of the mark.
+             * Optional options
              */
-            attributes?: Record<string, any>, options?: {
+            options?: {
                 /**
-                 * Removes the mark even across the current selection. Defaults to `false`.
+                 * Options for parsing the content.
                  */
-                extendEmptyMarkRange?: boolean;
+                parseOptions?: ParseOptions;
+                /**
+                 * Whether to update the selection after inserting the content.
+                 */
+                updateSelection?: boolean;
+                applyInputRules?: boolean;
+                applyPasteRules?: boolean;
             }) => ReturnType;
         };
     }
@@ -2671,670 +2609,811 @@ declare module '@tiptap/core' {
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        toggleNode: {
+        insertContentAt: {
             /**
-             * Toggle a node with another node.
-             * @param typeOrName The type or name of the node.
-             * @param toggleTypeOrName The type or name of the node to toggle.
-             * @param attributes The attributes of the node.
-             * @example editor.commands.toggleNode('heading', 'paragraph')
+             * Insert a node or string of HTML at a specific position.
+             * @example editor.commands.insertContentAt(0, '<h1>Example</h1>')
+             */
+            insertContentAt: (
+            /**
+             * The position to insert the content at.
+             */
+            position: number | Range, 
+            /**
+             * The ProseMirror content to insert.
+             */
+            value: Content | Node$1 | Fragment, 
+            /**
+             * Optional options
              */
-            toggleNode: (typeOrName: string | NodeType, toggleTypeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType;
+            options?: {
+                /**
+                 * Options for parsing the content.
+                 */
+                parseOptions?: ParseOptions;
+                /**
+                 * Whether to update the selection after inserting the content.
+                 */
+                updateSelection?: boolean;
+                /**
+                 * Whether to apply input rules after inserting the content.
+                 */
+                applyInputRules?: boolean;
+                /**
+                 * Whether to apply paste rules after inserting the content.
+                 */
+                applyPasteRules?: boolean;
+                /**
+                 * Whether to throw an error if the content is invalid.
+                 */
+                errorOnInvalidContent?: boolean;
+            }) => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        toggleWrap: {
+        joinUp: {
             /**
-             * Wraps nodes in another node, or removes an existing wrap.
-             * @param typeOrName The type or name of the node.
-             * @param attributes The attributes of the node.
-             * @example editor.commands.toggleWrap('blockquote')
+             * Join the selected block or, if there is a text selection, the closest ancestor block of the selection that can be joined, with the sibling above it.
+             * @example editor.commands.joinUp()
+             */
+            joinUp: () => ReturnType;
+        };
+        joinDown: {
+            /**
+             * Join the selected block, or the closest ancestor of the selection that can be joined, with the sibling after it.
+             * @example editor.commands.joinDown()
+             */
+            joinDown: () => ReturnType;
+        };
+        joinBackward: {
+            /**
+             * If the selection is empty and at the start of a textblock, try to reduce the distance between that block and the one before it—if there's a block directly before it that can be joined, join them.
+             * If not, try to move the selected block closer to the next one in the document structure by lifting it out of its
+             * parent or moving it into a parent of the previous block. Will use the view for accurate (bidi-aware) start-of-textblock detection if given.
+             * @example editor.commands.joinBackward()
+             */
+            joinBackward: () => ReturnType;
+        };
+        joinForward: {
+            /**
+             * If the selection is empty and the cursor is at the end of a textblock, try to reduce or remove the boundary between that block and the one after it,
+             * either by joining them or by moving the other block closer to this one in the tree structure.
+             * Will use the view for accurate start-of-textblock detection if given.
+             * @example editor.commands.joinForward()
              */
-            toggleWrap: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType;
+            joinForward: () => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        undoInputRule: {
+        joinItemBackward: {
             /**
-             * Undo an input rule.
-             * @example editor.commands.undoInputRule()
+             * Join two items backward.
+             * @example editor.commands.joinItemBackward()
              */
-            undoInputRule: () => ReturnType;
+            joinItemBackward: () => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        unsetAllMarks: {
+        joinItemForward: {
             /**
-             * Remove all marks in the current selection.
-             * @example editor.commands.unsetAllMarks()
+             * Join two items Forwards.
+             * @example editor.commands.joinItemForward()
              */
-            unsetAllMarks: () => ReturnType;
+            joinItemForward: () => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        unsetMark: {
-            /**
-             * Remove all marks in the current selection.
-             * @param typeOrName The mark type or name.
-             * @param options.extendEmptyMarkRange Removes the mark even across the current selection. Defaults to `false`.
-             * @example editor.commands.unsetMark('bold')
-             */
-            unsetMark: (
+        joinTextblockBackward: {
             /**
-             * The mark type or name.
+             * A more limited form of joinBackward that only tries to join the current textblock to the one before it, if the cursor is at the start of a textblock.
              */
-            typeOrName: string | MarkType, options?: {
-                /**
-                 * Removes the mark even across the current selection. Defaults to `false`.
-                 */
-                extendEmptyMarkRange?: boolean;
-            }) => ReturnType;
+            joinTextblockBackward: () => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        updateAttributes: {
-            /**
-             * Update attributes of a node or mark.
-             * @param typeOrName The type or name of the node or mark.
-             * @param attributes The attributes of the node or mark.
-             * @example editor.commands.updateAttributes('mention', { userId: "2" })
-             */
-            updateAttributes: (
-            /**
-             * The type or name of the node or mark.
-             */
-            typeOrName: string | NodeType | MarkType, 
+        joinTextblockForward: {
             /**
-             * The attributes of the node or mark.
+             * A more limited form of joinForward that only tries to join the current textblock to the one after it, if the cursor is at the end of a textblock.
              */
-            attributes: Record<string, any>) => ReturnType;
+            joinTextblockForward: () => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        wrapIn: {
+        keyboardShortcut: {
             /**
-             * Wraps nodes in another node.
-             * @param typeOrName The type or name of the node.
-             * @param attributes The attributes of the node.
-             * @example editor.commands.wrapIn('blockquote')
+             * Trigger a keyboard shortcut.
+             * @param name The name of the keyboard shortcut.
+             * @example editor.commands.keyboardShortcut('Mod-b')
              */
-            wrapIn: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType;
+            keyboardShortcut: (name: string) => ReturnType;
         };
     }
 }
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        wrapInList: {
+        lift: {
             /**
-             * Wrap a node in a list.
+             * Removes an existing wrap if possible lifting the node out of it
              * @param typeOrName The type or name of the node.
              * @param attributes The attributes of the node.
-             * @example editor.commands.wrapInList('bulletList')
+             * @example editor.commands.lift('paragraph')
+             * @example editor.commands.lift('heading', { level: 1 })
              */
-            wrapInList: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType;
+            lift: (typeOrName: string | NodeType$1, attributes?: Record<string, any>) => ReturnType;
         };
     }
 }
 
-declare const Commands$1: Extension<any, any>;
-
-declare const Drop: Extension<any, any>;
-
-declare const Editable: Extension<any, any>;
-
-declare const FocusEvents: Extension<any, any>;
-
-declare const Keymap: Extension<any, any>;
-
-declare const Paste: Extension<any, any>;
-
-declare const Tabindex: Extension<any, any>;
-
-declare const index_ClipboardTextSerializer: typeof ClipboardTextSerializer;
-declare const index_Drop: typeof Drop;
-declare const index_Editable: typeof Editable;
-declare const index_FocusEvents: typeof FocusEvents;
-declare const index_Keymap: typeof Keymap;
-declare const index_Paste: typeof Paste;
-declare const index_Tabindex: typeof Tabindex;
-declare namespace index {
-  export { index_ClipboardTextSerializer as ClipboardTextSerializer, Commands$1 as Commands, index_Drop as Drop, index_Editable as Editable, index_FocusEvents as FocusEvents, index_Keymap as Keymap, index_Paste as Paste, index_Tabindex as Tabindex };
-}
-
-interface TiptapEditorHTMLElement extends HTMLElement {
-    editor?: Editor;
-}
-declare class Editor extends EventEmitter<EditorEvents> {
-    private commandManager;
-    extensionManager: ExtensionManager;
-    private css;
-    schema: Schema;
-    view: EditorView;
-    isFocused: boolean;
-    /**
-     * The editor is considered initialized after the `create` event has been emitted.
-     */
-    isInitialized: boolean;
-    extensionStorage: Record<string, any>;
-    /**
-     * A unique ID for this editor instance.
-     */
-    instanceId: string;
-    options: EditorOptions;
-    constructor(options?: Partial<EditorOptions>);
-    /**
-     * Returns the editor storage.
-     */
-    get storage(): Record<string, any>;
-    /**
-     * An object of all registered commands.
-     */
-    get commands(): SingleCommands;
-    /**
-     * Create a command chain to call multiple commands at once.
-     */
-    chain(): ChainedCommands;
-    /**
-     * Check if a command or a command chain can be executed. Without executing it.
-     */
-    can(): CanCommands;
-    /**
-     * Inject CSS styles.
-     */
-    private injectCSS;
-    /**
-     * Update editor options.
-     *
-     * @param options A list of options
-     */
-    setOptions(options?: Partial<EditorOptions>): void;
-    /**
-     * Update editable state of the editor.
-     */
-    setEditable(editable: boolean, emitUpdate?: boolean): void;
-    /**
-     * Returns whether the editor is editable.
-     */
-    get isEditable(): boolean;
-    /**
-     * Returns the editor state.
-     */
-    get state(): EditorState;
-    /**
-     * Register a ProseMirror plugin.
-     *
-     * @param plugin A ProseMirror plugin
-     * @param handlePlugins Control how to merge the plugin into the existing plugins.
-     * @returns The new editor state
-     */
-    registerPlugin(plugin: Plugin, handlePlugins?: (newPlugin: Plugin, plugins: Plugin[]) => Plugin[]): EditorState;
-    /**
-     * Unregister a ProseMirror plugin.
-     *
-     * @param nameOrPluginKeyToRemove The plugins name
-     * @returns The new editor state or undefined if the editor is destroyed
-     */
-    unregisterPlugin(nameOrPluginKeyToRemove: string | PluginKey | (string | PluginKey)[]): EditorState | undefined;
-    /**
-     * Creates an extension manager.
-     */
-    private createExtensionManager;
-    /**
-     * Creates an command manager.
-     */
-    private createCommandManager;
-    /**
-     * Creates a ProseMirror schema.
-     */
-    private createSchema;
-    /**
-     * Creates a ProseMirror view.
-     */
-    private createView;
-    /**
-     * Creates all node views.
-     */
-    createNodeViews(): void;
-    /**
-     * Prepend class name to element.
-     */
-    prependClass(): void;
-    isCapturingTransaction: boolean;
-    private capturedTransaction;
-    captureTransaction(fn: Function): Transaction | null;
-    /**
-     * The callback over which to send transactions (state updates) produced by the view.
-     *
-     * @param transaction An editor state transaction
-     */
-    private dispatchTransaction;
-    /**
-     * Get attributes of the currently selected node or mark.
-     */
-    getAttributes(nameOrType: string | NodeType | MarkType): Record<string, any>;
-    /**
-     * Returns if the currently selected node or mark is active.
-     *
-     * @param name Name of the node or mark
-     * @param attributes Attributes of the node or mark
-     */
-    isActive(name: string, attributes?: {}): boolean;
-    isActive(attributes: {}): boolean;
-    /**
-     * Get the document as JSON.
-     */
-    getJSON(): JSONContent;
-    /**
-     * Get the document as HTML.
-     */
-    getHTML(): string;
-    /**
-     * Get the document as text.
-     */
-    getText(options?: {
-        blockSeparator?: string;
-        textSerializers?: Record<string, TextSerializer>;
-    }): string;
-    /**
-     * Check if there is no content.
-     */
-    get isEmpty(): boolean;
-    /**
-     * Get the number of characters for the current document.
-     *
-     * @deprecated
-     */
-    getCharacterCount(): number;
-    /**
-     * Destroy the editor.
-     */
-    destroy(): void;
-    /**
-     * Check if the editor is already destroyed.
-     */
-    get isDestroyed(): boolean;
-    $node(selector: string, attributes?: {
-        [key: string]: any;
-    }): NodePos | null;
-    $nodes(selector: string, attributes?: {
-        [key: string]: any;
-    }): NodePos[] | null;
-    $pos(pos: number): NodePos;
-    get $doc(): NodePos;
-}
-
-declare class CommandManager {
-    editor: Editor;
-    rawCommands: AnyCommands;
-    customState?: EditorState;
-    constructor(props: {
-        editor: Editor;
-        state?: EditorState;
-    });
-    get hasCustomState(): boolean;
-    get state(): EditorState;
-    get commands(): SingleCommands;
-    get chain(): () => ChainedCommands;
-    get can(): () => CanCommands;
-    createChain(startTr?: Transaction, shouldDispatch?: boolean): ChainedCommands;
-    createCan(startTr?: Transaction): CanCommands;
-    buildProps(tr: Transaction, shouldDispatch?: boolean): CommandProps;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        liftEmptyBlock: {
+            /**
+             * If the cursor is in an empty textblock that can be lifted, lift the block.
+             * @example editor.commands.liftEmptyBlock()
+             */
+            liftEmptyBlock: () => ReturnType;
+        };
+    }
 }
 
-/**
- * Returns a new `Transform` based on all steps of the passed transactions.
- * @param oldDoc The Prosemirror node to start from
- * @param transactions The transactions to combine
- * @returns A new `Transform` with all steps of the passed transactions
- */
-declare function combineTransactionSteps(oldDoc: Node$1, transactions: Transaction[]): Transform;
-
-/**
- * Takes a Transaction & Editor State and turns it into a chainable state object
- * @param config The transaction and state to create the chainable state from
- * @returns A chainable Editor state object
- */
-declare function createChainableState(config: {
-    transaction: Transaction;
-    state: EditorState;
-}): EditorState;
-
-/**
- * Create a new Prosemirror document node from content.
- * @param content The JSON or HTML content to create the document from
- * @param schema The Prosemirror schema to use for the document
- * @param parseOptions Options for the parser
- * @returns The created Prosemirror document node
- */
-declare function createDocument(content: Content | Node$1 | Fragment, schema: Schema, parseOptions?: ParseOptions, options?: {
-    errorOnInvalidContent?: boolean;
-}): Node$1;
-
-type CreateNodeFromContentOptions = {
-    slice?: boolean;
-    parseOptions?: ParseOptions;
-    errorOnInvalidContent?: boolean;
-};
-/**
- * Takes a JSON or HTML content and creates a Prosemirror node or fragment from it.
- * @param content The JSON or HTML content to create the node from
- * @param schema The Prosemirror schema to use for the node
- * @param options Options for the parser
- * @returns The created Prosemirror node or fragment
- */
-declare function createNodeFromContent(content: Content | Node$1 | Fragment, schema: Schema, options?: CreateNodeFromContentOptions): Node$1 | Fragment;
-
-/**
- * Gets the default block type at a given match
- * @param match The content match to get the default block type from
- * @returns The default block type or null
- */
-declare function defaultBlockAt(match: ContentMatch): NodeType | null;
-
-/**
- * Find children inside a Prosemirror node that match a predicate.
- * @param node The Prosemirror node to search in
- * @param predicate The predicate to match
- * @returns An array of nodes with their positions
- */
-declare function findChildren(node: Node$1, predicate: Predicate): NodeWithPos[];
-
-/**
- * Same as `findChildren` but searches only within a `range`.
- * @param node The Prosemirror node to search in
- * @param range The range to search in
- * @param predicate The predicate to match
- * @returns An array of nodes with their positions
- */
-declare function findChildrenInRange(node: Node$1, range: Range, predicate: Predicate): NodeWithPos[];
-
-/**
- * Finds the closest parent node to the current selection that matches a predicate.
- * @param predicate The predicate to match
- * @returns A command that finds the closest parent node to the current selection that matches the predicate
- * @example ```js
- * findParentNode(node => node.type.name === 'paragraph')
- * ```
- */
-declare function findParentNode(predicate: Predicate): (selection: Selection) => {
-    pos: number;
-    start: number;
-    depth: number;
-    node: prosemirror_model.Node;
-} | undefined;
-
-/**
- * Finds the closest parent node to a resolved position that matches a predicate.
- * @param $pos The resolved position to search from
- * @param predicate The predicate to match
- * @returns The closest parent node to the resolved position that matches the predicate
- * @example ```js
- * findParentNodeClosestToPos($from, node => node.type.name === 'paragraph')
- * ```
- */
-declare function findParentNodeClosestToPos($pos: ResolvedPos, predicate: Predicate): {
-    pos: number;
-    start: number;
-    depth: number;
-    node: Node$1;
-} | undefined;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        liftListItem: {
+            /**
+             * Create a command to lift the list item around the selection up into a wrapping list.
+             * @param typeOrName The type or name of the node.
+             * @example editor.commands.liftListItem('listItem')
+             */
+            liftListItem: (typeOrName: string | NodeType$1) => ReturnType;
+        };
+    }
+}
 
-/**
- * Generate HTML from a JSONContent
- * @param doc The JSONContent to generate HTML from
- * @param extensions The extensions to use for the schema
- * @returns The generated HTML
- */
-declare function generateHTML(doc: JSONContent, extensions: Extensions): string;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        newlineInCode: {
+            /**
+             * Add a newline character in code.
+             * @example editor.commands.newlineInCode()
+             */
+            newlineInCode: () => ReturnType;
+        };
+    }
+}
 
-/**
- * Generate JSONContent from HTML
- * @param html The HTML to generate JSONContent from
- * @param extensions The extensions to use for the schema
- * @returns The generated JSONContent
- */
-declare function generateJSON(html: string, extensions: Extensions): Record<string, any>;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        resetAttributes: {
+            /**
+             * Resets some node attributes to the default value.
+             * @param typeOrName The type or name of the node.
+             * @param attributes The attributes of the node to reset.
+             * @example editor.commands.resetAttributes('heading', 'level')
+             */
+            resetAttributes: (typeOrName: string | NodeType$1 | MarkType$1, attributes: string | string[]) => ReturnType;
+        };
+    }
+}
 
-/**
- * Generate raw text from a JSONContent
- * @param doc The JSONContent to generate text from
- * @param extensions The extensions to use for the schema
- * @param options Options for the text generation f.e. blockSeparator or textSerializers
- * @returns The generated text
- */
-declare function generateText(doc: JSONContent, extensions: Extensions, options?: {
-    blockSeparator?: string;
-    textSerializers?: Record<string, TextSerializer>;
-}): string;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        scrollIntoView: {
+            /**
+             * Scroll the selection into view.
+             * @example editor.commands.scrollIntoView()
+             */
+            scrollIntoView: () => ReturnType;
+        };
+    }
+}
 
-/**
- * Get node or mark attributes by type or name on the current editor state
- * @param state The current editor state
- * @param typeOrName The node or mark type or name
- * @returns The attributes of the node or mark or an empty object
- */
-declare function getAttributes(state: EditorState, typeOrName: string | NodeType | MarkType): Record<string, any>;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        selectAll: {
+            /**
+             * Select the whole document.
+             * @example editor.commands.selectAll()
+             */
+            selectAll: () => ReturnType;
+        };
+    }
+}
 
-/**
- * Get a list of all extension attributes defined in `addAttribute` and `addGlobalAttribute`.
- * @param extensions List of extensions
- */
-declare function getAttributesFromExtensions(extensions: Extensions): ExtensionAttribute[];
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        selectNodeBackward: {
+            /**
+             * Select a node backward.
+             * @example editor.commands.selectNodeBackward()
+             */
+            selectNodeBackward: () => ReturnType;
+        };
+    }
+}
 
-type ChangedRange = {
-    oldRange: Range;
-    newRange: Range;
-};
-/**
- * Returns a list of changed ranges
- * based on the first and last state of all steps.
- */
-declare function getChangedRanges(transform: Transform): ChangedRange[];
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        selectNodeForward: {
+            /**
+             * Select a node forward.
+             * @example editor.commands.selectNodeForward()
+             */
+            selectNodeForward: () => ReturnType;
+        };
+    }
+}
 
-interface DebugJSONContent extends JSONContent {
-    from: number;
-    to: number;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        selectParentNode: {
+            /**
+             * Select the parent node.
+             * @example editor.commands.selectParentNode()
+             */
+            selectParentNode: () => ReturnType;
+        };
+    }
 }
-declare function getDebugJSON(node: Node$1, startOffset?: number): DebugJSONContent;
 
-/**
- * Returns a field from an extension
- * @param extension The Tiptap extension
- * @param field The field, for example `renderHTML` or `priority`
- * @param context The context object that should be passed as `this` into the function
- * @returns The field value
- */
-declare function getExtensionField<T = any>(extension: AnyExtension, field: string, context?: Omit<MaybeThisParameterType<T>, 'parent'>): RemoveThis<T>;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        selectTextblockEnd: {
+            /**
+             * Moves the cursor to the end of current text block.
+             * @example editor.commands.selectTextblockEnd()
+             */
+            selectTextblockEnd: () => ReturnType;
+        };
+    }
+}
 
-declare function getHTMLFromFragment(fragment: Fragment, schema: Schema): string;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        selectTextblockStart: {
+            /**
+             * Moves the cursor to the start of current text block.
+             * @example editor.commands.selectTextblockStart()
+             */
+            selectTextblockStart: () => ReturnType;
+        };
+    }
+}
+
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        setContent: {
+            /**
+             * Replace the whole document with new content.
+             * @param content The new content.
+             * @param emitUpdate Whether to emit an update event.
+             * @param parseOptions Options for parsing the content.
+             * @example editor.commands.setContent('<p>Example text</p>')
+             */
+            setContent: (
+            /**
+             * The new content.
+             */
+            content: Content | Fragment | Node$1, 
+            /**
+             * Whether to emit an update event.
+             * @default false
+             */
+            emitUpdate?: boolean, 
+            /**
+             * Options for parsing the content.
+             * @default {}
+             */
+            parseOptions?: ParseOptions, 
+            /**
+             * Options for `setContent`.
+             */
+            options?: {
+                /**
+                 * Whether to throw an error if the content is invalid.
+                 */
+                errorOnInvalidContent?: boolean;
+            }) => ReturnType;
+        };
+    }
+}
 
-declare function getMarkAttributes(state: EditorState, typeOrName: string | MarkType): Record<string, any>;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        setMark: {
+            /**
+             * Add a mark with new attributes.
+             * @param typeOrName The mark type or name.
+             * @example editor.commands.setMark('bold', { level: 1 })
+             */
+            setMark: (typeOrName: string | MarkType$1, attributes?: Record<string, any>) => ReturnType;
+        };
+    }
+}
 
-/**
- * Get the range of a mark at a resolved position.
- */
-declare function getMarkRange(
-/**
- * The position to get the mark range for.
- */
-$pos: ResolvedPos, 
-/**
- * The mark type to get the range for.
- */
-type: MarkType, 
-/**
- * The attributes to match against.
- * If not provided, only the first mark at the position will be matched.
- */
-attributes?: Record<string, any>): Range | void;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        setMeta: {
+            /**
+             * Store a metadata property in the current transaction.
+             * @param key The key of the metadata property.
+             * @param value The value to store.
+             * @example editor.commands.setMeta('foo', 'bar')
+             */
+            setMeta: (key: string | Plugin | PluginKey, value: any) => ReturnType;
+        };
+    }
+}
 
-declare function getMarksBetween(from: number, to: number, doc: Node$1): MarkRange[];
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        setNode: {
+            /**
+             * Replace a given range with a node.
+             * @param typeOrName The type or name of the node
+             * @param attributes The attributes of the node
+             * @example editor.commands.setNode('paragraph')
+             */
+            setNode: (typeOrName: string | NodeType$1, attributes?: Record<string, any>) => ReturnType;
+        };
+    }
+}
 
-declare function getMarkType(nameOrType: string | MarkType, schema: Schema): MarkType;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        setNodeSelection: {
+            /**
+             * Creates a NodeSelection.
+             * @param position - Position of the node.
+             * @example editor.commands.setNodeSelection(10)
+             */
+            setNodeSelection: (position: number) => ReturnType;
+        };
+    }
+}
 
-/**
- * Finds the first node of a given type or name in the current selection.
- * @param state The editor state.
- * @param typeOrName The node type or name.
- * @param pos The position to start searching from.
- * @param maxDepth The maximum depth to search.
- * @returns The node and the depth as an array.
- */
-declare const getNodeAtPosition: (state: EditorState, typeOrName: string | NodeType, pos: number, maxDepth?: number) => [Node$1 | null, number];
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        setTextSelection: {
+            /**
+             * Creates a TextSelection.
+             * @param position The position of the selection.
+             * @example editor.commands.setTextSelection(10)
+             */
+            setTextSelection: (position: number | Range) => ReturnType;
+        };
+    }
+}
 
-declare function getNodeAttributes(state: EditorState, typeOrName: string | NodeType): Record<string, any>;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        sinkListItem: {
+            /**
+             * Sink the list item down into an inner list.
+             * @param typeOrName The type or name of the node.
+             * @example editor.commands.sinkListItem('listItem')
+             */
+            sinkListItem: (typeOrName: string | NodeType$1) => ReturnType;
+        };
+    }
+}
 
-declare function getNodeType(nameOrType: string | NodeType, schema: Schema): NodeType;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        splitBlock: {
+            /**
+             * Forks a new node from an existing node.
+             * @param options.keepMarks Keep marks from the previous node.
+             * @example editor.commands.splitBlock()
+             * @example editor.commands.splitBlock({ keepMarks: true })
+             */
+            splitBlock: (options?: {
+                keepMarks?: boolean;
+            }) => ReturnType;
+        };
+    }
+}
 
-declare function getRenderedAttributes(nodeOrMark: Node$1 | Mark$1, extensionAttributes: ExtensionAttribute[]): Record<string, any>;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        splitListItem: {
+            /**
+             * Splits one list item into two list items.
+             * @param typeOrName The type or name of the node.
+             * @param overrideAttrs The attributes to ensure on the new node.
+             * @example editor.commands.splitListItem('listItem')
+             */
+            splitListItem: (typeOrName: string | NodeType$1, overrideAttrs?: Record<string, any>) => ReturnType;
+        };
+    }
+}
 
-declare function getSchema(extensions: Extensions, editor?: Editor): Schema;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        toggleList: {
+            /**
+             * Toggle between different list types.
+             * @param listTypeOrName The type or name of the list.
+             * @param itemTypeOrName The type or name of the list item.
+             * @param keepMarks Keep marks when toggling.
+             * @param attributes Attributes for the new list.
+             * @example editor.commands.toggleList('bulletList', 'listItem')
+             */
+            toggleList: (listTypeOrName: string | NodeType$1, itemTypeOrName: string | NodeType$1, keepMarks?: boolean, attributes?: Record<string, any>) => ReturnType;
+        };
+    }
+}
 
-/**
- * Creates a new Prosemirror schema based on the given extensions.
- * @param extensions An array of Tiptap extensions
- * @param editor The editor instance
- * @returns A Prosemirror schema
- */
-declare function getSchemaByResolvedExtensions(extensions: Extensions, editor?: Editor): Schema;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        toggleMark: {
+            /**
+             * Toggle a mark on and off.
+             * @param typeOrName The mark type or name.
+             * @param attributes The attributes of the mark.
+             * @param options.extendEmptyMarkRange Removes the mark even across the current selection. Defaults to `false`.
+             * @example editor.commands.toggleMark('bold')
+             */
+            toggleMark: (
+            /**
+             * The mark type or name.
+             */
+            typeOrName: string | MarkType$1, 
+            /**
+             * The attributes of the mark.
+             */
+            attributes?: Record<string, any>, options?: {
+                /**
+                 * Removes the mark even across the current selection. Defaults to `false`.
+                 */
+                extendEmptyMarkRange?: boolean;
+            }) => ReturnType;
+        };
+    }
+}
 
-/**
- * Tries to get a node or mark type by its name.
- * @param name The name of the node or mark type
- * @param schema The Prosemiror schema to search in
- * @returns The node or mark type, or null if it doesn't exist
- */
-declare function getSchemaTypeByName(name: string, schema: Schema): NodeType | MarkType | null;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        toggleNode: {
+            /**
+             * Toggle a node with another node.
+             * @param typeOrName The type or name of the node.
+             * @param toggleTypeOrName The type or name of the node to toggle.
+             * @param attributes The attributes of the node.
+             * @example editor.commands.toggleNode('heading', 'paragraph')
+             */
+            toggleNode: (typeOrName: string | NodeType$1, toggleTypeOrName: string | NodeType$1, attributes?: Record<string, any>) => ReturnType;
+        };
+    }
+}
 
-/**
- * Get the type of a schema item by its name.
- * @param name The name of the schema item
- * @param schema The Prosemiror schema to search in
- * @returns The type of the schema item (`node` or `mark`), or null if it doesn't exist
- */
-declare function getSchemaTypeNameByName(name: string, schema: Schema): 'node' | 'mark' | null;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        toggleWrap: {
+            /**
+             * Wraps nodes in another node, or removes an existing wrap.
+             * @param typeOrName The type or name of the node.
+             * @param attributes The attributes of the node.
+             * @example editor.commands.toggleWrap('blockquote')
+             */
+            toggleWrap: (typeOrName: string | NodeType$1, attributes?: Record<string, any>) => ReturnType;
+        };
+    }
+}
 
-/**
- * Return attributes of an extension that should be splitted by keepOnSplit flag
- * @param extensionAttributes Array of extension attributes
- * @param typeName The type of the extension
- * @param attributes The attributes of the extension
- * @returns The splitted attributes
- */
-declare function getSplittedAttributes(extensionAttributes: ExtensionAttribute[], typeName: string, attributes: Record<string, any>): Record<string, any>;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        undoInputRule: {
+            /**
+             * Undo an input rule.
+             * @example editor.commands.undoInputRule()
+             */
+            undoInputRule: () => ReturnType;
+        };
+    }
+}
 
-/**
- * Gets the text of a Prosemirror node
- * @param node The Prosemirror node
- * @param options Options for the text serializer & block separator
- * @returns The text of the node
- * @example ```js
- * const text = getText(node, { blockSeparator: '\n' })
- * ```
- */
-declare function getText(node: Node$1, options?: {
-    blockSeparator?: string;
-    textSerializers?: Record<string, TextSerializer>;
-}): string;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        unsetAllMarks: {
+            /**
+             * Remove all marks in the current selection.
+             * @example editor.commands.unsetAllMarks()
+             */
+            unsetAllMarks: () => ReturnType;
+        };
+    }
+}
 
-/**
- * Gets the text between two positions in a Prosemirror node
- * and serializes it using the given text serializers and block separator (see getText)
- * @param startNode The Prosemirror node to start from
- * @param range The range of the text to get
- * @param options Options for the text serializer & block separator
- * @returns The text between the two positions
- */
-declare function getTextBetween(startNode: Node$1, range: Range, options?: {
-    blockSeparator?: string;
-    textSerializers?: Record<string, TextSerializer>;
-}): string;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        unsetMark: {
+            /**
+             * Remove all marks in the current selection.
+             * @param typeOrName The mark type or name.
+             * @param options.extendEmptyMarkRange Removes the mark even across the current selection. Defaults to `false`.
+             * @example editor.commands.unsetMark('bold')
+             */
+            unsetMark: (
+            /**
+             * The mark type or name.
+             */
+            typeOrName: string | MarkType$1, options?: {
+                /**
+                 * Removes the mark even across the current selection. Defaults to `false`.
+                 */
+                extendEmptyMarkRange?: boolean;
+            }) => ReturnType;
+        };
+    }
+}
 
-/**
- * Returns the text content of a resolved prosemirror position
- * @param $from The resolved position to get the text content from
- * @param maxMatch The maximum number of characters to match
- * @returns The text content
- */
-declare const getTextContentFromNodes: ($from: ResolvedPos, maxMatch?: number) => string;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        updateAttributes: {
+            /**
+             * Update attributes of a node or mark.
+             * @param typeOrName The type or name of the node or mark.
+             * @param attributes The attributes of the node or mark.
+             * @example editor.commands.updateAttributes('mention', { userId: "2" })
+             */
+            updateAttributes: (
+            /**
+             * The type or name of the node or mark.
+             */
+            typeOrName: string | NodeType$1 | MarkType$1, 
+            /**
+             * The attributes of the node or mark.
+             */
+            attributes: Record<string, any>) => ReturnType;
+        };
+    }
+}
 
-/**
- * Find text serializers `toText` in a Prosemirror schema
- * @param schema The Prosemirror schema to search in
- * @returns A record of text serializers by node name
- */
-declare function getTextSerializersFromSchema(schema: Schema): Record<string, TextSerializer>;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        wrapIn: {
+            /**
+             * Wraps nodes in another node.
+             * @param typeOrName The type or name of the node.
+             * @param attributes The attributes of the node.
+             * @example editor.commands.wrapIn('blockquote')
+             */
+            wrapIn: (typeOrName: string | NodeType$1, attributes?: Record<string, any>) => ReturnType;
+        };
+    }
+}
 
-/**
- * This function merges extension attributes into parserule attributes (`attrs` or `getAttrs`).
- * Cancels when `getAttrs` returned `false`.
- * @param parseRule ProseMirror ParseRule
- * @param extensionAttributes List of attributes to inject
- */
-declare function injectExtensionAttributesToParseRule(parseRule: ParseRule, extensionAttributes: ExtensionAttribute[]): ParseRule;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        wrapInList: {
+            /**
+             * Wrap a node in a list.
+             * @param typeOrName The type or name of the node.
+             * @param attributes The attributes of the node.
+             * @example editor.commands.wrapInList('bulletList')
+             */
+            wrapInList: (typeOrName: string | NodeType$1, attributes?: Record<string, any>) => ReturnType;
+        };
+    }
+}
 
-declare function isActive(state: EditorState, name: string | null, attributes?: Record<string, any>): boolean;
+declare const Commands$1: Extension<any, any>;
 
-declare const isAtEndOfNode: (state: EditorState, nodeType?: string) => boolean;
+declare const Drop: Extension<any, any>;
 
-declare const isAtStartOfNode: (state: EditorState) => boolean;
+declare const Editable: Extension<any, any>;
 
-declare function isExtensionRulesEnabled(extension: AnyExtension, enabled: EnableRules): boolean;
+declare const FocusEvents: Extension<any, any>;
 
-declare function isList(name: string, extensions: Extensions): boolean;
+declare const Keymap: Extension<any, any>;
 
-declare function isMarkActive(state: EditorState, typeOrName: MarkType | string | null, attributes?: Record<string, any>): boolean;
+declare const Paste: Extension<any, any>;
 
-declare function isNodeActive(state: EditorState, typeOrName: NodeType | string | null, attributes?: Record<string, any>): boolean;
+declare const Tabindex: Extension<any, any>;
 
-/**
- * Returns true if the given prosemirror node is empty.
- */
-declare function isNodeEmpty(node: Node$1, { checkChildren, ignoreWhitespace, }?: {
+declare const index_ClipboardTextSerializer: typeof ClipboardTextSerializer;
+declare const index_Drop: typeof Drop;
+declare const index_Editable: typeof Editable;
+declare const index_FocusEvents: typeof FocusEvents;
+declare const index_Keymap: typeof Keymap;
+declare const index_Paste: typeof Paste;
+declare const index_Tabindex: typeof Tabindex;
+declare namespace index {
+  export { index_ClipboardTextSerializer as ClipboardTextSerializer, Commands$1 as Commands, index_Drop as Drop, index_Editable as Editable, index_FocusEvents as FocusEvents, index_Keymap as Keymap, index_Paste as Paste, index_Tabindex as Tabindex };
+}
+
+interface TiptapEditorHTMLElement extends HTMLElement {
+    editor?: Editor;
+}
+declare class Editor extends EventEmitter<EditorEvents> {
+    private commandManager;
+    extensionManager: ExtensionManager;
+    private css;
+    schema: Schema;
+    view: EditorView;
+    isFocused: boolean;
     /**
-     * When true (default), it will also check if all children are empty.
+     * The editor is considered initialized after the `create` event has been emitted.
      */
-    checkChildren?: boolean;
+    isInitialized: boolean;
+    extensionStorage: Record<string, any>;
     /**
-     * When true, it will ignore whitespace when checking for emptiness.
+     * A unique ID for this editor instance.
      */
-    ignoreWhitespace?: boolean;
-}): boolean;
-
-declare function isNodeSelection(value: unknown): value is NodeSelection;
-
-declare function isTextSelection(value: unknown): value is TextSelection;
-
-declare function posToDOMRect(view: EditorView, from: number, to: number): DOMRect;
-
-declare function resolveFocusPosition(doc: Node$1, position?: FocusPosition): Selection | null;
-
-declare function selectionToInsertionEnd(tr: Transaction, startLen: number, bias: number): void;
+    instanceId: string;
+    options: EditorOptions;
+    constructor(options?: Partial<EditorOptions>);
+    /**
+     * Returns the editor storage.
+     */
+    get storage(): Record<string, any>;
+    /**
+     * An object of all registered commands.
+     */
+    get commands(): SingleCommands;
+    /**
+     * Create a command chain to call multiple commands at once.
+     */
+    chain(): ChainedCommands;
+    /**
+     * Check if a command or a command chain can be executed. Without executing it.
+     */
+    can(): CanCommands;
+    /**
+     * Inject CSS styles.
+     */
+    private injectCSS;
+    /**
+     * Update editor options.
+     *
+     * @param options A list of options
+     */
+    setOptions(options?: Partial<EditorOptions>): void;
+    /**
+     * Update editable state of the editor.
+     */
+    setEditable(editable: boolean, emitUpdate?: boolean): void;
+    /**
+     * Returns whether the editor is editable.
+     */
+    get isEditable(): boolean;
+    /**
+     * Returns the editor state.
+     */
+    get state(): EditorState;
+    /**
+     * Register a ProseMirror plugin.
+     *
+     * @param plugin A ProseMirror plugin
+     * @param handlePlugins Control how to merge the plugin into the existing plugins.
+     * @returns The new editor state
+     */
+    registerPlugin(plugin: Plugin, handlePlugins?: (newPlugin: Plugin, plugins: Plugin[]) => Plugin[]): EditorState;
+    /**
+     * Unregister a ProseMirror plugin.
+     *
+     * @param nameOrPluginKeyToRemove The plugins name
+     * @returns The new editor state or undefined if the editor is destroyed
+     */
+    unregisterPlugin(nameOrPluginKeyToRemove: string | PluginKey | (string | PluginKey)[]): EditorState | undefined;
+    /**
+     * Creates an extension manager.
+     */
+    private createExtensionManager;
+    /**
+     * Creates an command manager.
+     */
+    private createCommandManager;
+    /**
+     * Creates a ProseMirror schema.
+     */
+    private createSchema;
+    /**
+     * Creates a ProseMirror view.
+     */
+    private createView;
+    /**
+     * Creates all node views.
+     */
+    createNodeViews(): void;
+    /**
+     * Prepend class name to element.
+     */
+    prependClass(): void;
+    isCapturingTransaction: boolean;
+    private capturedTransaction;
+    captureTransaction(fn: () => void): Transaction | null;
+    /**
+     * The callback over which to send transactions (state updates) produced by the view.
+     *
+     * @param transaction An editor state transaction
+     */
+    private dispatchTransaction;
+    /**
+     * Get attributes of the currently selected node or mark.
+     */
+    getAttributes(nameOrType: string | NodeType$1 | MarkType$1): Record<string, any>;
+    /**
+     * Returns if the currently selected node or mark is active.
+     *
+     * @param name Name of the node or mark
+     * @param attributes Attributes of the node or mark
+     */
+    isActive(name: string, attributes?: {}): boolean;
+    isActive(attributes: {}): boolean;
+    /**
+     * Get the document as JSON.
+     */
+    getJSON(): DocumentType<Record<string, any> | undefined, NodeType<string, undefined | Record<string, any>, any, (NodeType | TextType)[]>[]>;
+    /**
+     * Get the document as HTML.
+     */
+    getHTML(): string;
+    /**
+     * Get the document as text.
+     */
+    getText(options?: {
+        blockSeparator?: string;
+        textSerializers?: Record<string, TextSerializer>;
+    }): string;
+    /**
+     * Check if there is no content.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Destroy the editor.
+     */
+    destroy(): void;
+    /**
+     * Check if the editor is already destroyed.
+     */
+    get isDestroyed(): boolean;
+    $node(selector: string, attributes?: {
+        [key: string]: any;
+    }): NodePos | null;
+    $nodes(selector: string, attributes?: {
+        [key: string]: any;
+    }): NodePos[] | null;
+    $pos(pos: number): NodePos;
+    get $doc(): NodePos;
+}
 
-declare function splitExtensions(extensions: Extensions): {
-    baseExtensions: Extension<any, any>[];
-    nodeExtensions: Node<any, any>[];
-    markExtensions: Mark<any, any>[];
-};
+declare class CommandManager {
+    editor: Editor;
+    rawCommands: AnyCommands;
+    customState?: EditorState;
+    constructor(props: {
+        editor: Editor;
+        state?: EditorState;
+    });
+    get hasCustomState(): boolean;
+    get state(): EditorState;
+    get commands(): SingleCommands;
+    get chain(): () => ChainedCommands;
+    get can(): () => CanCommands;
+    createChain(startTr?: Transaction, shouldDispatch?: boolean): ChainedCommands;
+    createCan(startTr?: Transaction): CanCommands;
+    buildProps(tr: Transaction, shouldDispatch?: boolean): CommandProps;
+}
 
 /**
  * Build an input rule that adds a mark when the
@@ -3343,7 +3422,7 @@ declare function splitExtensions(extensions: Extensions): {
  */
 declare function markInputRule(config: {
     find: InputRuleFinder;
-    type: MarkType;
+    type: MarkType$1;
     getAttributes?: Record<string, any> | ((match: ExtendedRegExpMatchArray) => Record<string, any>) | false | null;
 }): InputRule;
 
@@ -3360,7 +3439,7 @@ declare function nodeInputRule(config: {
     /**
      * The node type to add.
      */
-    type: NodeType;
+    type: NodeType$1;
     /**
      * A function that returns the attributes for the node
      * can also be an object of attributes
@@ -3377,7 +3456,7 @@ declare function nodeInputRule(config: {
  */
 declare function textblockTypeInputRule(config: {
     find: InputRuleFinder;
-    type: NodeType;
+    type: NodeType$1;
     getAttributes?: Record<string, any> | ((match: ExtendedRegExpMatchArray) => Record<string, any>) | false | null;
 }): InputRule;
 
@@ -3408,7 +3487,7 @@ declare function textInputRule(config: {
  */
 declare function wrappingInputRule(config: {
     find: InputRuleFinder;
-    type: NodeType;
+    type: NodeType$1;
     keepMarks?: boolean;
     keepAttributes?: boolean;
     editor?: Editor;
@@ -3461,7 +3540,7 @@ declare class NodeView<Component, NodeEditor extends Editor = Editor, Options ex
  */
 declare function markPasteRule(config: {
     find: PasteRuleFinder;
-    type: MarkType;
+    type: MarkType$1;
     getAttributes?: Record<string, any> | ((match: ExtendedRegExpMatchArray, event: ClipboardEvent) => Record<string, any>) | false | null;
 }): PasteRule;
 
@@ -3472,7 +3551,7 @@ declare function markPasteRule(config: {
  */
 declare function nodePasteRule(config: {
     find: PasteRuleFinder;
-    type: NodeType;
+    type: NodeType$1;
     getAttributes?: Record<string, any> | ((match: ExtendedRegExpMatchArray, event: ClipboardEvent) => Record<string, any>) | false | null;
     getContent?: JSONContent[] | ((attrs: Record<string, any>) => JSONContent[]) | false | null;
 }): PasteRule;
@@ -3520,7 +3599,10 @@ declare function elementFromString(value: string): HTMLElement;
 
 declare function escapeForRegEx(string: string): string;
 
-declare function findDuplicates(items: any[]): any[];
+/**
+ * Find duplicates in an array.
+ */
+declare function findDuplicates<T>(items: T[]): T[];
 
 declare function fromString(value: any): any;
 
@@ -3573,4 +3655,4 @@ interface NodeConfig<Options = any, Storage = any> {
 interface MarkConfig<Options = any, Storage = any> {
 }
 
-export { type AnyCommands, type AnyConfig, type AnyExtension, type Attribute, type Attributes, type CanCommands, type ChainedCommands, type ChangedRange, type Command, CommandManager, type CommandProps, type CommandSpec, type Commands, type Content, type CreateNodeFromContentOptions, type DOMNode, type DecorationType, type DecorationWithType, type Diff, type Dispatch, Editor, type EditorEvents, type EditorOptions, type EnableRules, type ExtendedRegExpMatchArray, Extension, type ExtensionAttribute, type ExtensionConfig, type Extensions, type FocusPosition, type GlobalAttributes, type HTMLContent, InputRule, type InputRuleFinder, type InputRuleMatch, type JSONContent, type KeyboardShortcutCommand, type KeysWithTypeOf, Mark, type MarkConfig, type MarkRange, type MaybeReturnType, type MaybeThisParameterType, Node, type NodeConfig, NodePos, type NodeRange, NodeView, type NodeViewProps, type NodeViewRenderer, type NodeViewRendererOptions, type NodeViewRendererProps, type NodeWithPos, type Overwrite, type ParentConfig, PasteRule, type PasteRuleFinder, type PasteRuleMatch, type PickValue, type Predicate, type Primitive, type Range, type RawCommands, type RemoveThis, type SingleCommands, type TextSerializer, type TiptapEditorHTMLElement, Tracker, type TrackerResult, type UnionCommands, type UnionToIntersection, type ValuesOf, callOrReturn, combineTransactionSteps, createChainableState, createDocument, createNodeFromContent, createStyleTag, defaultBlockAt, deleteProps, elementFromString, escapeForRegEx, index as extensions, findChildren, findChildrenInRange, findDuplicates, findParentNode, findParentNodeClosestToPos, fromString, generateHTML, generateJSON, generateText, getAttributes, getAttributesFromExtensions, getChangedRanges, getDebugJSON, getExtensionField, getHTMLFromFragment, getMarkAttributes, getMarkRange, getMarkType, getMarksBetween, getNodeAtPosition, getNodeAttributes, getNodeType, getRenderedAttributes, getSchema, getSchemaByResolvedExtensions, getSchemaTypeByName, getSchemaTypeNameByName, getSplittedAttributes, getText, getTextBetween, getTextContentFromNodes, getTextSerializersFromSchema, injectExtensionAttributesToParseRule, inputRulesPlugin, isActive, isAtEndOfNode, isAtStartOfNode, isEmptyObject, isExtensionRulesEnabled, isFunction, isList, isMacOS, isMarkActive, isNodeActive, isNodeEmpty, isNodeSelection, isNumber, isPlainObject, isRegExp, isString, isTextSelection, isiOS, markInputRule, markPasteRule, mergeAttributes, mergeDeep, minMax, nodeInputRule, nodePasteRule, objectIncludes, pasteRulesPlugin, posToDOMRect, removeDuplicates, resolveFocusPosition, selectionToInsertionEnd, splitExtensions, textInputRule, textPasteRule, textblockTypeInputRule, wrappingInputRule };
+export { type AnyCommands, type AnyConfig, type AnyExtension, type Attribute, type Attributes, type CanCommands, type ChainedCommands, type ChangedRange, type Command, CommandManager, type CommandProps, type CommandSpec, type Commands, type Content, type CreateNodeFromContentOptions, type DOMNode, type DOMOutputSpecArray, type DecorationType, type DecorationWithType, type Diff, type Dispatch, type DocumentType, Editor, type EditorEvents, type EditorOptions, type EnableRules, type ExtendedRegExpMatchArray, Extension, type ExtensionAttribute, type ExtensionConfig, type Extensions, type FocusPosition, type GlobalAttributes, type HTMLContent, InputRule, type InputRuleFinder, type InputRuleMatch, type JSONContent, type KeyboardShortcutCommand, type KeysWithTypeOf, Mark, type MarkConfig, type MarkRange, type MarkType, type MaybeReturnType, type MaybeThisParameterType, Node, type NodeConfig, NodePos, type NodeRange, type NodeType, NodeView, type NodeViewProps, type NodeViewRenderer, type NodeViewRendererOptions, type NodeViewRendererProps, type NodeWithPos, type Overwrite, type ParentConfig, PasteRule, type PasteRuleFinder, type PasteRuleMatch, type PickValue, type Predicate, type Primitive, type Range, type RawCommands, type RemoveThis, type SingleCommands, type TextSerializer, type TextType, type TiptapEditorHTMLElement, Tracker, type TrackerResult, type UnionCommands, type UnionToIntersection, type ValuesOf, callOrReturn, combineTransactionSteps, createChainableState, createDocument, createNodeFromContent, createStyleTag, defaultBlockAt, deleteProps, elementFromString, escapeForRegEx, index as extensions, findChildren, findChildrenInRange, findDuplicates, findParentNode, findParentNodeClosestToPos, flattenExtensions, fromString, generateHTML, generateJSON, generateText, getAttributes, getAttributesFromExtensions, getChangedRanges, getDebugJSON, getExtensionField, getHTMLFromFragment, getMarkAttributes, getMarkRange, getMarkType, getMarksBetween, getNodeAtPosition, getNodeAttributes, getNodeType, getRenderedAttributes, getSchema, getSchemaByResolvedExtensions, getSchemaTypeByName, getSchemaTypeNameByName, getSplittedAttributes, getText, getTextBetween, getTextContentFromNodes, getTextSerializersFromSchema, injectExtensionAttributesToParseRule, inputRulesPlugin, isActive, isAtEndOfNode, isAtStartOfNode, isEmptyObject, isExtensionRulesEnabled, isFunction, isList, isMacOS, isMarkActive, isNodeActive, isNodeEmpty, isNodeSelection, isNumber, isPlainObject, isRegExp, isString, isTextSelection, isiOS, markInputRule, markPasteRule, mergeAttributes, mergeDeep, minMax, nodeInputRule, nodePasteRule, objectIncludes, pasteRulesPlugin, posToDOMRect, removeDuplicates, resolveExtensions, resolveFocusPosition, rewriteUnknownContent, selectionToInsertionEnd, sortExtensions, splitExtensions, textInputRule, textPasteRule, textblockTypeInputRule, wrappingInputRule };