@docen/extensions 0.0.8

package/dist/shared/extensions.BQfevE5S.d.cts

@@ -0,0 +1,1793 @@
+import { N as Node, a as Node$1, P as ParentConfig, b as EditorView, c as NodeView, R as ResizableNodeViewDirection, d as PluginKey, e as Editor, f as Range, g as EditorState, h as ResolvedPos, D as DOMOutputSpec, M as Mark, i as Extension } from './extensions.SlCx0Bmn.cjs';
+import '@tiptap/extension-mathematics';
+
+/**
+ * The default document node which represents the top level node of the editor.
+ * @see https://tiptap.dev/api/nodes/document
+ */
+declare const Document: Node<any, any>;
+
+/**
+ * This extension allows you to create text nodes.
+ * @see https://www.tiptap.dev/api/nodes/text
+ */
+declare const Text: Node<any, any>;
+
+interface ParagraphOptions {
+    /**
+     * The HTML attributes for a paragraph node.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        paragraph: {
+            /**
+             * Toggle a paragraph
+             * @example editor.commands.toggleParagraph()
+             */
+            setParagraph: () => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to create paragraphs.
+ * @see https://www.tiptap.dev/api/nodes/paragraph
+ */
+declare const Paragraph: Node<ParagraphOptions, any>;
+
+/**
+ * The heading level options.
+ */
+type Level = 1 | 2 | 3 | 4 | 5 | 6;
+interface HeadingOptions {
+    /**
+     * The available heading levels.
+     * @default [1, 2, 3, 4, 5, 6]
+     * @example [1, 2, 3]
+     */
+    levels: Level[];
+    /**
+     * The HTML attributes for a heading node.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        heading: {
+            /**
+             * Set a heading node
+             * @param attributes The heading attributes
+             * @example editor.commands.setHeading({ level: 1 })
+             */
+            setHeading: (attributes: {
+                level: Level;
+            }) => ReturnType;
+            /**
+             * Toggle a heading node
+             * @param attributes The heading attributes
+             * @example editor.commands.toggleHeading({ level: 1 })
+             */
+            toggleHeading: (attributes: {
+                level: Level;
+            }) => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to create headings.
+ * @see https://www.tiptap.dev/api/nodes/heading
+ */
+declare const Heading: Node<HeadingOptions, any>;
+
+/** @jsxImportSource @tiptap/core */
+
+interface BlockquoteOptions {
+    /**
+     * HTML attributes to add to the blockquote element
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        blockQuote: {
+            /**
+             * Set a blockquote node
+             */
+            setBlockquote: () => ReturnType;
+            /**
+             * Toggle a blockquote node
+             */
+            toggleBlockquote: () => ReturnType;
+            /**
+             * Unset a blockquote node
+             */
+            unsetBlockquote: () => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to create blockquotes.
+ * @see https://tiptap.dev/api/nodes/blockquote
+ */
+declare const Blockquote: Node<BlockquoteOptions, any>;
+
+interface HorizontalRuleOptions {
+    /**
+     * The HTML attributes for a horizontal rule node.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+    /**
+     * The default type to insert after the horizontal rule.
+     * @default "paragraph"
+     * @example "heading"
+     */
+    nextNodeType: string;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        horizontalRule: {
+            /**
+             * Add a horizontal rule
+             * @example editor.commands.setHorizontalRule()
+             */
+            setHorizontalRule: () => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to insert horizontal rules.
+ * @see https://www.tiptap.dev/api/nodes/horizontal-rule
+ */
+declare const HorizontalRule: Node<HorizontalRuleOptions, any>;
+
+interface CodeBlockOptions {
+    /**
+     * Adds a prefix to language classes that are applied to code tags.
+     * @default 'language-'
+     */
+    languageClassPrefix: string | null | undefined;
+    /**
+     * Define whether the node should be exited on triple enter.
+     * @default true
+     */
+    exitOnTripleEnter: boolean | null | undefined;
+    /**
+     * Define whether the node should be exited on arrow down if there is no node after it.
+     * @default true
+     */
+    exitOnArrowDown: boolean | null | undefined;
+    /**
+     * The default language.
+     * @default null
+     * @example 'js'
+     */
+    defaultLanguage: string | null | undefined;
+    /**
+     * Enable tab key for indentation in code blocks.
+     * @default false
+     */
+    enableTabIndentation: boolean | null | undefined;
+    /**
+     * The number of spaces to use for tab indentation.
+     * @default 4
+     */
+    tabSize: number | null | undefined;
+    /**
+     * Custom HTML attributes that should be added to the rendered HTML tag.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        codeBlock: {
+            /**
+             * Set a code block
+             * @param attributes Code block attributes
+             * @example editor.commands.setCodeBlock({ language: 'javascript' })
+             */
+            setCodeBlock: (attributes?: {
+                language: string;
+            }) => ReturnType;
+            /**
+             * Toggle a code block
+             * @param attributes Code block attributes
+             * @example editor.commands.toggleCodeBlock({ language: 'javascript' })
+             */
+            toggleCodeBlock: (attributes?: {
+                language: string;
+            }) => ReturnType;
+        };
+    }
+}
+
+interface CodeBlockLowlightOptions extends CodeBlockOptions {
+    /**
+     * The lowlight instance.
+     */
+    lowlight: any;
+}
+/**
+ * This extension allows you to highlight code blocks with lowlight.
+ * @see https://tiptap.dev/api/nodes/code-block-lowlight
+ */
+declare const CodeBlockLowlight: Node<CodeBlockLowlightOptions, any>;
+
+interface BulletListOptions {
+    /**
+     * The node name for the list items
+     * @default 'listItem'
+     * @example 'paragraph'
+     */
+    itemTypeName: string;
+    /**
+     * HTML attributes to add to the bullet list element
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+    /**
+     * Keep the marks when splitting the list
+     * @default false
+     * @example true
+     */
+    keepMarks: boolean;
+    /**
+     * Keep the attributes when splitting the list
+     * @default false
+     * @example true
+     */
+    keepAttributes: boolean;
+}
+/**
+ * This extension allows you to create bullet lists.
+ * This requires the ListItem extension
+ * @see https://tiptap.dev/api/nodes/bullet-list
+ * @see https://tiptap.dev/api/nodes/list-item.
+ */
+declare const BulletList: Node<BulletListOptions, any>;
+
+interface ListItemOptions {
+    /**
+     * The HTML attributes for a list item node.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+    /**
+     * The node type for bulletList nodes
+     * @default 'bulletList'
+     * @example 'myCustomBulletList'
+     */
+    bulletListTypeName: string;
+    /**
+     * The node type for orderedList nodes
+     * @default 'orderedList'
+     * @example 'myCustomOrderedList'
+     */
+    orderedListTypeName: string;
+}
+/**
+ * This extension allows you to create list items.
+ * @see https://www.tiptap.dev/api/nodes/list-item
+ */
+declare const ListItem: Node<ListItemOptions, any>;
+
+interface OrderedListOptions {
+    /**
+     * The node type name for list items.
+     * @default 'listItem'
+     * @example 'myListItem'
+     */
+    itemTypeName: string;
+    /**
+     * The HTML attributes for an ordered list node.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+    /**
+     * Keep the marks when splitting a list item.
+     * @default false
+     * @example true
+     */
+    keepMarks: boolean;
+    /**
+     * Keep the attributes when splitting a list item.
+     * @default false
+     * @example true
+     */
+    keepAttributes: boolean;
+}
+/**
+ * This extension allows you to create ordered lists.
+ * This requires the ListItem extension
+ * @see https://www.tiptap.dev/api/nodes/ordered-list
+ * @see https://www.tiptap.dev/api/nodes/list-item
+ */
+declare const OrderedList: Node<OrderedListOptions, any>;
+
+interface TaskItemOptions {
+    /**
+     * A callback function that is called when the checkbox is clicked while the editor is in readonly mode.
+     * @param node The prosemirror node of the task item
+     * @param checked The new checked state
+     * @returns boolean
+     */
+    onReadOnlyChecked?: (node: Node$1, checked: boolean) => boolean;
+    /**
+     * Controls whether the task items can be nested or not.
+     * @default false
+     * @example true
+     */
+    nested: boolean;
+    /**
+     * HTML attributes to add to the task item element.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+    /**
+     * The node type for taskList nodes
+     * @default 'taskList'
+     * @example 'myCustomTaskList'
+     */
+    taskListTypeName: string;
+    /**
+     * Accessibility options for the task item.
+     * @default {}
+     * @example
+     * ```js
+     * {
+     *   checkboxLabel: (node) => `Task item: ${node.textContent || 'empty task item'}`
+     * }
+     */
+    a11y?: {
+        checkboxLabel?: (node: Node$1, checked: boolean) => string;
+    };
+}
+/**
+ * This extension allows you to create task items.
+ * @see https://www.tiptap.dev/api/nodes/task-item
+ */
+declare const TaskItem: Node<TaskItemOptions, any>;
+
+interface TaskListOptions {
+    /**
+     * The node type name for a task item.
+     * @default 'taskItem'
+     * @example 'myCustomTaskItem'
+     */
+    itemTypeName: string;
+    /**
+     * The HTML attributes for a task list node.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        bulletList: {
+            /**
+             * Toggle a bullet list
+             */
+            toggleBulletList: () => ReturnType;
+        };
+    }
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        orderedList: {
+            /**
+             * Toggle an ordered list
+             * @example editor.commands.toggleOrderedList()
+             */
+            toggleOrderedList: () => ReturnType;
+        };
+    }
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        taskList: {
+            /**
+             * Toggle a task list
+             * @example editor.commands.toggleTaskList()
+             */
+            toggleTaskList: () => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to create task lists.
+ * @see https://www.tiptap.dev/api/nodes/task-list
+ */
+declare const TaskList: Node<TaskListOptions, any>;
+
+interface TableCellOptions {
+    /**
+     * The HTML attributes for a table cell node.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+/**
+ * This extension allows you to create table cells.
+ * @see https://www.tiptap.dev/api/nodes/table-cell
+ */
+declare const TableCell: Node<TableCellOptions, any>;
+
+interface TableHeaderOptions {
+    /**
+     * The HTML attributes for a table header node.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+/**
+ * This extension allows you to create table headers.
+ * @see https://www.tiptap.dev/api/nodes/table-header
+ */
+declare const TableHeader: Node<TableHeaderOptions, any>;
+
+interface TableRowOptions {
+    /**
+     * The HTML attributes for a table row node.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+/**
+ * This extension allows you to create table rows.
+ * @see https://www.tiptap.dev/api/nodes/table-row
+ */
+declare const TableRow: Node<TableRowOptions, any>;
+
+interface TableOptions {
+    /**
+     * HTML attributes for the table element.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+    /**
+     * Enables the resizing of tables.
+     * @default false
+     * @example true
+     */
+    resizable: boolean;
+    /**
+     * Controls whether the table should be wrapped in a div with class "tableWrapper" when rendered.
+     * In editable mode with resizable tables, this wrapper is always present via TableView.
+     * @default false
+     * @example true
+     */
+    renderWrapper: boolean;
+    /**
+     * The width of the resize handle.
+     * @default 5
+     * @example 10
+     */
+    handleWidth: number;
+    /**
+     * The minimum width of a cell.
+     * @default 25
+     * @example 50
+     */
+    cellMinWidth: number;
+    /**
+     * The node view to render the table.
+     * @default TableView
+     */
+    View: (new (node: Node$1, cellMinWidth: number, view: EditorView) => NodeView) | null;
+    /**
+     * Enables the resizing of the last column.
+     * @default true
+     * @example false
+     */
+    lastColumnResizable: boolean;
+    /**
+     * Allow table node selection.
+     * @default false
+     * @example true
+     */
+    allowTableNodeSelection: boolean;
+}
+
+declare module '@tiptap/core' {
+    interface NodeConfig<Options, Storage> {
+        /**
+         * A string or function to determine the role of the table.
+         * @default 'table'
+         * @example () => 'table'
+         */
+        tableRole?: string | ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options>>['tableRole'];
+        }) => string);
+    }
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        table: {
+            /**
+             * Insert a table
+             * @param options The table attributes
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.insertTable({ rows: 3, cols: 3, withHeaderRow: true })
+             */
+            insertTable: (options?: {
+                rows?: number;
+                cols?: number;
+                withHeaderRow?: boolean;
+            }) => ReturnType;
+            /**
+             * Add a column before the current column
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.addColumnBefore()
+             */
+            addColumnBefore: () => ReturnType;
+            /**
+             * Add a column after the current column
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.addColumnAfter()
+             */
+            addColumnAfter: () => ReturnType;
+            /**
+             * Delete the current column
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.deleteColumn()
+             */
+            deleteColumn: () => ReturnType;
+            /**
+             * Add a row before the current row
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.addRowBefore()
+             */
+            addRowBefore: () => ReturnType;
+            /**
+             * Add a row after the current row
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.addRowAfter()
+             */
+            addRowAfter: () => ReturnType;
+            /**
+             * Delete the current row
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.deleteRow()
+             */
+            deleteRow: () => ReturnType;
+            /**
+             * Delete the current table
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.deleteTable()
+             */
+            deleteTable: () => ReturnType;
+            /**
+             * Merge the currently selected cells
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.mergeCells()
+             */
+            mergeCells: () => ReturnType;
+            /**
+             * Split the currently selected cell
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.splitCell()
+             */
+            splitCell: () => ReturnType;
+            /**
+             * Toggle the header column
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.toggleHeaderColumn()
+             */
+            toggleHeaderColumn: () => ReturnType;
+            /**
+             * Toggle the header row
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.toggleHeaderRow()
+             */
+            toggleHeaderRow: () => ReturnType;
+            /**
+             * Toggle the header cell
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.toggleHeaderCell()
+             */
+            toggleHeaderCell: () => ReturnType;
+            /**
+             * Merge or split the currently selected cells
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.mergeOrSplit()
+             */
+            mergeOrSplit: () => ReturnType;
+            /**
+             * Set a cell attribute
+             * @param name The attribute name
+             * @param value The attribute value
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.setCellAttribute('align', 'right')
+             */
+            setCellAttribute: (name: string, value: any) => ReturnType;
+            /**
+             * Moves the selection to the next cell
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.goToNextCell()
+             */
+            goToNextCell: () => ReturnType;
+            /**
+             * Moves the selection to the previous cell
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.goToPreviousCell()
+             */
+            goToPreviousCell: () => ReturnType;
+            /**
+             * Try to fix the table structure if necessary
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.fixTables()
+             */
+            fixTables: () => ReturnType;
+            /**
+             * Set a cell selection inside the current table
+             * @param position The cell position
+             * @returns True if the command was successful, otherwise false
+             * @example editor.commands.setCellSelection({ anchorCell: 1, headCell: 2 })
+             */
+            setCellSelection: (position: {
+                anchorCell: number;
+                headCell?: number;
+            }) => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to create tables.
+ * @see https://www.tiptap.dev/api/nodes/table
+ */
+declare const Table: Node<TableOptions, any>;
+
+interface ImageOptions {
+    /**
+     * Controls if the image node should be inline or not.
+     * @default false
+     * @example true
+     */
+    inline: boolean;
+    /**
+     * Controls if base64 images are allowed. Enable this if you want to allow
+     * base64 image urls in the `src` attribute.
+     * @default false
+     * @example true
+     */
+    allowBase64: boolean;
+    /**
+     * HTML attributes to add to the image element.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+    /**
+     * Controls if the image should be resizable and how the resize is configured.
+     * @default false
+     * @example { directions: { top: true, right: true, bottom: true, left: true, topLeft: true, topRight: true, bottomLeft: true, bottomRight: true }, minWidth: 100, minHeight: 100 }
+     */
+    resize: {
+        enabled: boolean;
+        directions?: ResizableNodeViewDirection[];
+        minWidth?: number;
+        minHeight?: number;
+        alwaysPreserveAspectRatio?: boolean;
+    } | false;
+}
+interface SetImageOptions {
+    src: string;
+    alt?: string;
+    title?: string;
+    width?: number;
+    height?: number;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        image: {
+            /**
+             * Add an image
+             * @param options The image attributes
+             * @example
+             * editor
+             *   .commands
+             *   .setImage({ src: 'https://tiptap.dev/logo.png', alt: 'tiptap', title: 'tiptap logo' })
+             */
+            setImage: (options: SetImageOptions) => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to insert images.
+ * @see https://www.tiptap.dev/api/nodes/image
+ */
+declare const Image: Node<ImageOptions, any>;
+
+interface HardBreakOptions {
+    /**
+     * Controls if marks should be kept after being split by a hard break.
+     * @default true
+     * @example false
+     */
+    keepMarks: boolean;
+    /**
+     * HTML attributes to add to the hard break element.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        hardBreak: {
+            /**
+             * Add a hard break
+             * @example editor.commands.setHardBreak()
+             */
+            setHardBreak: () => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to insert hard breaks.
+ * @see https://www.tiptap.dev/api/nodes/hard-break
+ */
+declare const HardBreak: Node<HardBreakOptions, any>;
+
+interface DetailsOptions {
+    /**
+     * Specify if the open status should be saved in the document. Defaults to `false`.
+     */
+    persist: boolean;
+    /**
+     * Specifies a CSS class that is set when toggling the content. Defaults to `is-open`.
+     */
+    openClassName: string;
+    /**
+     * Custom HTML attributes that should be added to the rendered HTML tag.
+     */
+    HTMLAttributes: {
+        [key: string]: any;
+    };
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        details: {
+            /**
+             * Set a details node
+             */
+            setDetails: () => ReturnType;
+            /**
+             * Unset a details node
+             */
+            unsetDetails: () => ReturnType;
+        };
+    }
+}
+declare const Details: Node<DetailsOptions, any>;
+
+interface DetailsContentOptions {
+    /**
+     * Custom HTML attributes that should be added to the rendered HTML tag.
+     */
+    HTMLAttributes: {
+        [key: string]: any;
+    };
+}
+declare const DetailsContent: Node<DetailsContentOptions, any>;
+
+interface DetailsSummaryOptions {
+    /**
+     * Custom HTML attributes that should be added to the rendered HTML tag.
+     */
+    HTMLAttributes: {
+        [key: string]: any;
+    };
+}
+declare const DetailsSummary: Node<DetailsSummaryOptions, any>;
+
+interface Trigger {
+    char: string;
+    allowSpaces: boolean;
+    allowToIncludeChar: boolean;
+    allowedPrefixes: string[] | null;
+    startOfLine: boolean;
+    $position: ResolvedPos;
+}
+type SuggestionMatch = {
+    range: Range;
+    query: string;
+    text: string;
+} | null;
+declare function findSuggestionMatch(config: Trigger): SuggestionMatch;
+
+interface SuggestionOptions<I = any, TSelected = any> {
+    /**
+     * The plugin key for the suggestion plugin.
+     * @default 'suggestion'
+     * @example 'mention'
+     */
+    pluginKey?: PluginKey;
+    /**
+     * The editor instance.
+     * @default null
+     */
+    editor: Editor;
+    /**
+     * The character that triggers the suggestion.
+     * @default '@'
+     * @example '#'
+     */
+    char?: string;
+    /**
+     * Allow spaces in the suggestion query. Not compatible with `allowToIncludeChar`. Will be disabled if `allowToIncludeChar` is set to `true`.
+     * @default false
+     * @example true
+     */
+    allowSpaces?: boolean;
+    /**
+     * Allow the character to be included in the suggestion query. Not compatible with `allowSpaces`.
+     * @default false
+     */
+    allowToIncludeChar?: boolean;
+    /**
+     * Allow prefixes in the suggestion query.
+     * @default [' ']
+     * @example [' ', '@']
+     */
+    allowedPrefixes?: string[] | null;
+    /**
+     * Only match suggestions at the start of the line.
+     * @default false
+     * @example true
+     */
+    startOfLine?: boolean;
+    /**
+     * The tag name of the decoration node.
+     * @default 'span'
+     * @example 'div'
+     */
+    decorationTag?: string;
+    /**
+     * The class name of the decoration node.
+     * @default 'suggestion'
+     * @example 'mention'
+     */
+    decorationClass?: string;
+    /**
+     * Creates a decoration with the provided content.
+     * @param decorationContent - The content to display in the decoration
+     * @default "" - Creates an empty decoration if no content provided
+     */
+    decorationContent?: string;
+    /**
+     * The class name of the decoration node when it is empty.
+     * @default 'is-empty'
+     * @example 'is-empty'
+     */
+    decorationEmptyClass?: string;
+    /**
+     * A function that is called when a suggestion is selected.
+     * @param props The props object.
+     * @param props.editor The editor instance.
+     * @param props.range The range of the suggestion.
+     * @param props.props The props of the selected suggestion.
+     * @returns void
+     * @example ({ editor, range, props }) => { props.command(props.props) }
+     */
+    command?: (props: {
+        editor: Editor;
+        range: Range;
+        props: TSelected;
+    }) => void;
+    /**
+     * A function that returns the suggestion items in form of an array.
+     * @param props The props object.
+     * @param props.editor The editor instance.
+     * @param props.query The current suggestion query.
+     * @returns An array of suggestion items.
+     * @example ({ editor, query }) => [{ id: 1, label: 'John Doe' }]
+     */
+    items?: (props: {
+        query: string;
+        editor: Editor;
+    }) => I[] | Promise<I[]>;
+    /**
+     * The render function for the suggestion.
+     * @returns An object with render functions.
+     */
+    render?: () => {
+        onBeforeStart?: (props: SuggestionProps<I, TSelected>) => void;
+        onStart?: (props: SuggestionProps<I, TSelected>) => void;
+        onBeforeUpdate?: (props: SuggestionProps<I, TSelected>) => void;
+        onUpdate?: (props: SuggestionProps<I, TSelected>) => void;
+        onExit?: (props: SuggestionProps<I, TSelected>) => void;
+        onKeyDown?: (props: SuggestionKeyDownProps) => boolean;
+    };
+    /**
+     * A function that returns a boolean to indicate if the suggestion should be active.
+     * @param props The props object.
+     * @returns {boolean}
+     */
+    allow?: (props: {
+        editor: Editor;
+        state: EditorState;
+        range: Range;
+        isActive?: boolean;
+    }) => boolean;
+    findSuggestionMatch?: typeof findSuggestionMatch;
+}
+interface SuggestionProps<I = any, TSelected = any> {
+    /**
+     * The editor instance.
+     */
+    editor: Editor;
+    /**
+     * The range of the suggestion.
+     */
+    range: Range;
+    /**
+     * The current suggestion query.
+     */
+    query: string;
+    /**
+     * The current suggestion text.
+     */
+    text: string;
+    /**
+     * The suggestion items array.
+     */
+    items: I[];
+    /**
+     * A function that is called when a suggestion is selected.
+     * @param props The props object.
+     * @returns void
+     */
+    command: (props: TSelected) => void;
+    /**
+     * The decoration node HTML element
+     * @default null
+     */
+    decorationNode: Element | null;
+    /**
+     * The function that returns the client rect
+     * @default null
+     * @example () => new DOMRect(0, 0, 0, 0)
+     */
+    clientRect?: (() => DOMRect | null) | null;
+}
+interface SuggestionKeyDownProps {
+    view: EditorView;
+    event: KeyboardEvent;
+    range: Range;
+}
+
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        emoji: {
+            /**
+             * Add an emoji
+             */
+            setEmoji: (shortcode: string) => ReturnType;
+        };
+    }
+    interface Storage {
+        emoji: EmojiStorage;
+    }
+}
+type EmojiItem = {
+    /**
+     * A unique name of the emoji which will be stored as attribute
+     */
+    name: string;
+    /**
+     * The emoji unicode character
+     */
+    emoji?: string;
+    /**
+     * A list of unique shortcodes that are used by input rules to find the emoji
+     */
+    shortcodes: string[];
+    /**
+     * A list of tags that can help for searching emojis
+     */
+    tags: string[];
+    /**
+     * A name that can help to group emojis
+     */
+    group?: string;
+    /**
+     * A list of unique emoticons
+     */
+    emoticons?: string[];
+    /**
+     * The unicode version the emoji was introduced
+     */
+    version?: number;
+    /**
+     * A fallback image if the current system doesn't support the emoji or for custom emojis
+     */
+    fallbackImage?: string;
+    /**
+     * Store some custom data
+     */
+    [key: string]: any;
+};
+type EmojiOptions = {
+    HTMLAttributes: Record<string, any>;
+    emojis: EmojiItem[];
+    enableEmoticons: boolean;
+    forceFallbackImages: boolean;
+    suggestion: Omit<SuggestionOptions, 'editor'>;
+};
+type EmojiStorage = {
+    emojis: EmojiItem[];
+    isSupported: (item: EmojiItem) => boolean;
+};
+declare const Emoji: Node<EmojiOptions, EmojiStorage>;
+
+interface MentionNodeAttrs {
+    /**
+     * The identifier for the selected item that was mentioned, stored as a `data-id`
+     * attribute.
+     */
+    id: string | null;
+    /**
+     * The label to be rendered by the editor as the displayed text for this mentioned
+     * item, if provided. Stored as a `data-label` attribute. See `renderLabel`.
+     */
+    label?: string | null;
+    /**
+     * The character that triggers the suggestion, stored as
+     * `data-mention-suggestion-char` attribute.
+     */
+    mentionSuggestionChar?: string;
+}
+interface MentionOptions<SuggestionItem = any, Attrs extends Record<string, any> = MentionNodeAttrs> {
+    /**
+     * The HTML attributes for a mention node.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+    /**
+     * A function to render the label of a mention.
+     * @deprecated use renderText and renderHTML instead
+     * @param props The render props
+     * @returns The label
+     * @example ({ options, node }) => `${options.suggestion.char}${node.attrs.label ?? node.attrs.id}`
+     */
+    renderLabel?: (props: {
+        options: MentionOptions<SuggestionItem, Attrs>;
+        node: Node$1;
+        suggestion: SuggestionOptions | null;
+    }) => string;
+    /**
+     * A function to render the text of a mention.
+     * @param props The render props
+     * @returns The text
+     * @example ({ options, node }) => `${options.suggestion.char}${node.attrs.label ?? node.attrs.id}`
+     */
+    renderText: (props: {
+        options: MentionOptions<SuggestionItem, Attrs>;
+        node: Node$1;
+        suggestion: SuggestionOptions | null;
+    }) => string;
+    /**
+     * A function to render the HTML of a mention.
+     * @param props The render props
+     * @returns The HTML as a ProseMirror DOM Output Spec
+     * @example ({ options, node }) => ['span', { 'data-type': 'mention' }, `${options.suggestion.char}${node.attrs.label ?? node.attrs.id}`]
+     */
+    renderHTML: (props: {
+        options: MentionOptions<SuggestionItem, Attrs>;
+        node: Node$1;
+        suggestion: SuggestionOptions | null;
+    }) => DOMOutputSpec;
+    /**
+     * Whether to delete the trigger character with backspace.
+     * @default false
+     */
+    deleteTriggerWithBackspace: boolean;
+    /**
+     * The suggestion options, when you want to support multiple triggers.
+     *
+     * With this parameter, you can define multiple types of mention. For example, you can use the `@` character
+     * to mention users and the `#` character to mention tags.
+     *
+     * @default [{ char: '@', pluginKey: MentionPluginKey }]
+     * @example [{ char: '@', pluginKey: MentionPluginKey }, { char: '#', pluginKey: new PluginKey('hashtag') }]
+     */
+    suggestions: Array<Omit<SuggestionOptions<SuggestionItem, Attrs>, 'editor'>>;
+    /**
+     * The suggestion options, when you want to support only one trigger. To support multiple triggers, use the
+     * `suggestions` parameter instead.
+     *
+     * @default {}
+     * @example { char: '@', pluginKey: MentionPluginKey, command: ({ editor, range, props }) => { ... } }
+     */
+    suggestion: Omit<SuggestionOptions<SuggestionItem, Attrs>, 'editor'>;
+}
+/**
+ * This extension allows you to insert mentions into the editor.
+ * @see https://www.tiptap.dev/api/extensions/mention
+ */
+declare const Mention: Node<MentionOptions<any, MentionNodeAttrs>, any>;
+
+/** @jsxImportSource @tiptap/core */
+
+interface BoldOptions {
+    /**
+     * HTML attributes to add to the bold element.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        bold: {
+            /**
+             * Set a bold mark
+             */
+            setBold: () => ReturnType;
+            /**
+             * Toggle a bold mark
+             */
+            toggleBold: () => ReturnType;
+            /**
+             * Unset a bold mark
+             */
+            unsetBold: () => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to mark text as bold.
+ * @see https://tiptap.dev/api/marks/bold
+ */
+declare const Bold: Mark<BoldOptions, any>;
+
+interface ItalicOptions {
+    /**
+     * HTML attributes to add to the italic element.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        italic: {
+            /**
+             * Set an italic mark
+             * @example editor.commands.setItalic()
+             */
+            setItalic: () => ReturnType;
+            /**
+             * Toggle an italic mark
+             * @example editor.commands.toggleItalic()
+             */
+            toggleItalic: () => ReturnType;
+            /**
+             * Unset an italic mark
+             * @example editor.commands.unsetItalic()
+             */
+            unsetItalic: () => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to create italic text.
+ * @see https://www.tiptap.dev/api/marks/italic
+ */
+declare const Italic: Mark<ItalicOptions, any>;
+
+interface UnderlineOptions {
+    /**
+     * HTML attributes to add to the underline element.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        underline: {
+            /**
+             * Set an underline mark
+             * @example editor.commands.setUnderline()
+             */
+            setUnderline: () => ReturnType;
+            /**
+             * Toggle an underline mark
+             * @example editor.commands.toggleUnderline()
+             */
+            toggleUnderline: () => ReturnType;
+            /**
+             * Unset an underline mark
+             * @example editor.commands.unsetUnderline()
+             */
+            unsetUnderline: () => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to create underline text.
+ * @see https://www.tiptap.dev/api/marks/underline
+ */
+declare const Underline: Mark<UnderlineOptions, any>;
+
+interface StrikeOptions {
+    /**
+     * HTML attributes to add to the strike element.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        strike: {
+            /**
+             * Set a strike mark
+             * @example editor.commands.setStrike()
+             */
+            setStrike: () => ReturnType;
+            /**
+             * Toggle a strike mark
+             * @example editor.commands.toggleStrike()
+             */
+            toggleStrike: () => ReturnType;
+            /**
+             * Unset a strike mark
+             * @example editor.commands.unsetStrike()
+             */
+            unsetStrike: () => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to create strike text.
+ * @see https://www.tiptap.dev/api/marks/strike
+ */
+declare const Strike: Mark<StrikeOptions, any>;
+
+interface CodeOptions {
+    /**
+     * The HTML attributes applied to the code element.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        code: {
+            /**
+             * Set a code mark
+             */
+            setCode: () => ReturnType;
+            /**
+             * Toggle inline code
+             */
+            toggleCode: () => ReturnType;
+            /**
+             * Unset a code mark
+             */
+            unsetCode: () => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to mark text as inline code.
+ * @see https://tiptap.dev/api/marks/code
+ */
+declare const Code: Mark<CodeOptions, any>;
+
+interface LinkProtocolOptions {
+    /**
+     * The protocol scheme to be registered.
+     * @default '''
+     * @example 'ftp'
+     * @example 'git'
+     */
+    scheme: string;
+    /**
+     * If enabled, it allows optional slashes after the protocol.
+     * @default false
+     * @example true
+     */
+    optionalSlashes?: boolean;
+}
+/**
+ * @deprecated The default behavior is now to open links when the editor is not editable.
+ */
+type DeprecatedOpenWhenNotEditable = 'whenNotEditable';
+interface LinkOptions {
+    /**
+     * If enabled, the extension will automatically add links as you type.
+     * @default true
+     * @example false
+     */
+    autolink: boolean;
+    /**
+     * An array of custom protocols to be registered with linkifyjs.
+     * @default []
+     * @example ['ftp', 'git']
+     */
+    protocols: Array<LinkProtocolOptions | string>;
+    /**
+     * Default protocol to use when no protocol is specified.
+     * @default 'http'
+     */
+    defaultProtocol: string;
+    /**
+     * If enabled, links will be opened on click.
+     * @default true
+     * @example false
+     */
+    openOnClick: boolean | DeprecatedOpenWhenNotEditable;
+    /**
+     * If enabled, the link will be selected when clicked.
+     * @default false
+     * @example true
+     */
+    enableClickSelection: boolean;
+    /**
+     * Adds a link to the current selection if the pasted content only contains an url.
+     * @default true
+     * @example false
+     */
+    linkOnPaste: boolean;
+    /**
+     * HTML attributes to add to the link element.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+    /**
+     * @deprecated Use the `shouldAutoLink` option instead.
+     * A validation function that modifies link verification for the auto linker.
+     * @param url - The url to be validated.
+     * @returns - True if the url is valid, false otherwise.
+     */
+    validate: (url: string) => boolean;
+    /**
+     * A validation function which is used for configuring link verification for preventing XSS attacks.
+     * Only modify this if you know what you're doing.
+     *
+     * @returns {boolean} `true` if the URL is valid, `false` otherwise.
+     *
+     * @example
+     * isAllowedUri: (url, { defaultValidate, protocols, defaultProtocol }) => {
+     * return url.startsWith('./') || defaultValidate(url)
+     * }
+     */
+    isAllowedUri: (
+    /**
+     * The URL to be validated.
+     */
+    url: string, ctx: {
+        /**
+         * The default validation function.
+         */
+        defaultValidate: (url: string) => boolean;
+        /**
+         * An array of allowed protocols for the URL (e.g., "http", "https"). As defined in the `protocols` option.
+         */
+        protocols: Array<LinkProtocolOptions | string>;
+        /**
+         * A string that represents the default protocol (e.g., 'http'). As defined in the `defaultProtocol` option.
+         */
+        defaultProtocol: string;
+    }) => boolean;
+    /**
+     * Determines whether a valid link should be automatically linked in the content.
+     *
+     * @param {string} url - The URL that has already been validated.
+     * @returns {boolean} - True if the link should be auto-linked; false if it should not be auto-linked.
+     */
+    shouldAutoLink: (url: string) => boolean;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        link: {
+            /**
+             * Set a link mark
+             * @param attributes The link attributes
+             * @example editor.commands.setLink({ href: 'https://tiptap.dev' })
+             */
+            setLink: (attributes: {
+                href: string;
+                target?: string | null;
+                rel?: string | null;
+                class?: string | null;
+            }) => ReturnType;
+            /**
+             * Toggle a link mark
+             * @param attributes The link attributes
+             * @example editor.commands.toggleLink({ href: 'https://tiptap.dev' })
+             */
+            toggleLink: (attributes?: {
+                href: string;
+                target?: string | null;
+                rel?: string | null;
+                class?: string | null;
+            }) => ReturnType;
+            /**
+             * Unset a link mark
+             * @example editor.commands.unsetLink()
+             */
+            unsetLink: () => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to create links.
+ * @see https://www.tiptap.dev/api/marks/link
+ */
+declare const Link: Mark<LinkOptions, any>;
+
+interface HighlightOptions {
+    /**
+     * Allow multiple highlight colors
+     * @default false
+     * @example true
+     */
+    multicolor: boolean;
+    /**
+     * HTML attributes to add to the highlight element.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        highlight: {
+            /**
+             * Set a highlight mark
+             * @param attributes The highlight attributes
+             * @example editor.commands.setHighlight({ color: 'red' })
+             */
+            setHighlight: (attributes?: {
+                color: string;
+            }) => ReturnType;
+            /**
+             * Toggle a highlight mark
+             * @param attributes The highlight attributes
+             * @example editor.commands.toggleHighlight({ color: 'red' })
+             */
+            toggleHighlight: (attributes?: {
+                color: string;
+            }) => ReturnType;
+            /**
+             * Unset a highlight mark
+             * @example editor.commands.unsetHighlight()
+             */
+            unsetHighlight: () => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to highlight text.
+ * @see https://www.tiptap.dev/api/marks/highlight
+ */
+declare const Highlight: Mark<HighlightOptions, any>;
+
+interface SubscriptExtensionOptions {
+    /**
+     * HTML attributes to add to the subscript element.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        subscript: {
+            /**
+             * Set a subscript mark
+             * @example editor.commands.setSubscript()
+             */
+            setSubscript: () => ReturnType;
+            /**
+             * Toggle a subscript mark
+             * @example editor.commands.toggleSubscript()
+             */
+            toggleSubscript: () => ReturnType;
+            /**
+             * Unset a subscript mark
+             * @example editor.commands.unsetSubscript()
+             */
+            unsetSubscript: () => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to create subscript text.
+ * @see https://www.tiptap.dev/api/marks/subscript
+ */
+declare const Subscript: Mark<SubscriptExtensionOptions, any>;
+
+interface SuperscriptExtensionOptions {
+    /**
+     * HTML attributes to add to the superscript element.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        superscript: {
+            /**
+             * Set a superscript mark
+             * @example editor.commands.setSuperscript()
+             */
+            setSuperscript: () => ReturnType;
+            /**
+             * Toggle a superscript mark
+             * @example editor.commands.toggleSuperscript()
+             */
+            toggleSuperscript: () => ReturnType;
+            /**
+             * Unset a superscript mark
+             *  @example editor.commands.unsetSuperscript()
+             */
+            unsetSuperscript: () => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to create superscript text.
+ * @see https://www.tiptap.dev/api/marks/superscript
+ */
+declare const Superscript: Mark<SuperscriptExtensionOptions, any>;
+
+interface TextStyleOptions {
+    /**
+     * HTML attributes to add to the span element.
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, any>;
+    /**
+     * When enabled, merges the styles of nested spans into the child span during HTML parsing.
+     * This prioritizes the style of the child span.
+     * Used when parsing content created in other editors.
+     * (Fix for ProseMirror's default behavior.)
+     * @default true
+     */
+    mergeNestedSpanStyles: boolean;
+}
+/**
+ * This extension allows you to create text styles. It is required by default
+ * for the `text-color` and `font-family` extensions.
+ * @see https://www.tiptap.dev/api/marks/text-style
+ */
+declare const TextStyle: Mark<TextStyleOptions, any>;
+
+type BackgroundColorOptions = {
+    /**
+     * The types where the color can be applied
+     * @default ['textStyle']
+     * @example ['heading', 'paragraph']
+     */
+    types: string[];
+};
+/**
+ * This extension allows you to color your text.
+ * @see https://tiptap.dev/api/extensions/background-color
+ */
+declare const BackgroundColor: Extension<BackgroundColorOptions, any>;
+
+type ColorOptions = {
+    /**
+     * The types where the color can be applied
+     * @default ['textStyle']
+     * @example ['heading', 'paragraph']
+     */
+    types: string[];
+};
+/**
+ * This extension allows you to color your text.
+ * @see https://tiptap.dev/api/extensions/color
+ */
+declare const Color: Extension<ColorOptions, any>;
+
+type FontFamilyOptions = {
+    /**
+     * A list of node names where the font family can be applied.
+     * @default ['textStyle']
+     * @example ['heading', 'paragraph']
+     */
+    types: string[];
+};
+/**
+ * This extension allows you to set a font family for text.
+ * @see https://www.tiptap.dev/api/extensions/font-family
+ */
+declare const FontFamily: Extension<FontFamilyOptions, any>;
+
+type FontSizeOptions = {
+    /**
+     * A list of node names where the font size can be applied.
+     * @default ['textStyle']
+     * @example ['heading', 'paragraph']
+     */
+    types: string[];
+};
+/**
+ * This extension allows you to set a font size for text.
+ * @see https://www.tiptap.dev/api/extensions/font-size
+ */
+declare const FontSize: Extension<FontSizeOptions, any>;
+
+type LineHeightOptions = {
+    /**
+     * A list of node names where the line height can be applied.
+     * @default ['textStyle']
+     * @example ['heading', 'paragraph']
+     */
+    types: string[];
+};
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        textStyle: {
+            /**
+             * Remove spans without inline style attributes.
+             * @example editor.commands.removeEmptyTextStyle()
+             */
+            removeEmptyTextStyle: () => ReturnType;
+            /**
+             * Toggle a text style
+             * @param attributes The text style attributes
+             * @example editor.commands.toggleTextStyle({ fontWeight: 'bold' })
+             */
+            toggleTextStyle: (attributes?: TextStyleAttributes) => ReturnType;
+        };
+    }
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        backgroundColor: {
+            /**
+             * Set the text color
+             * @param backgroundColor The color to set
+             * @example editor.commands.setColor('red')
+             */
+            setBackgroundColor: (backgroundColor: string) => ReturnType;
+            /**
+             * Unset the text backgroundColor
+             * @example editor.commands.unsetBackgroundColor()
+             */
+            unsetBackgroundColor: () => ReturnType;
+        };
+    }
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        color: {
+            /**
+             * Set the text color
+             * @param color The color to set
+             * @example editor.commands.setColor('red')
+             */
+            setColor: (color: string) => ReturnType;
+            /**
+             * Unset the text color
+             * @example editor.commands.unsetColor()
+             */
+            unsetColor: () => ReturnType;
+        };
+    }
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        fontFamily: {
+            /**
+             * Set the font family
+             * @param fontFamily The font family
+             * @example editor.commands.setFontFamily('Arial')
+             */
+            setFontFamily: (fontFamily: string) => ReturnType;
+            /**
+             * Unset the font family
+             * @example editor.commands.unsetFontFamily()
+             */
+            unsetFontFamily: () => ReturnType;
+        };
+    }
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        fontSize: {
+            /**
+             * Set the font size
+             * @param fontSize The font size
+             * @example editor.commands.setFontSize('16px')
+             */
+            setFontSize: (fontSize: string) => ReturnType;
+            /**
+             * Unset the font size
+             * @example editor.commands.unsetFontSize()
+             */
+            unsetFontSize: () => ReturnType;
+        };
+    }
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        lineHeight: {
+            /**
+             * Set the line height
+             * @param lineHeight The line height
+             * @example editor.commands.setLineHeight('1.5')
+             */
+            setLineHeight: (lineHeight: string) => ReturnType;
+            /**
+             * Unset the line height
+             * @example editor.commands.unsetLineHeight()
+             */
+            unsetLineHeight: () => ReturnType;
+        };
+    }
+}
+declare module '@tiptap/extension-text-style' {
+    interface TextStyleAttributes {
+        backgroundColor?: string | null;
+    }
+}
+declare module '@tiptap/extension-text-style' {
+    interface TextStyleAttributes {
+        color?: string | null;
+    }
+}
+declare module '@tiptap/extension-text-style' {
+    interface TextStyleAttributes {
+        fontFamily?: string | null;
+    }
+}
+declare module '@tiptap/extension-text-style' {
+    interface TextStyleAttributes {
+        fontSize?: string | null;
+    }
+}
+declare module '@tiptap/extension-text-style' {
+    interface TextStyleAttributes {
+        lineHeight?: string | null;
+    }
+}
+/**
+ * This extension allows you to set the line-height for text.
+ * @see https://www.tiptap.dev/api/extensions/line-height
+ */
+declare const LineHeight: Extension<LineHeightOptions, any>;
+
+/**
+ * The available text style attributes.
+ */
+interface TextStyleAttributes extends Record<string, any> {
+}
+
+export { TableRow as A, Blockquote as B, CodeBlockLowlight as C, Document as D, Emoji as E, FontFamily as F, Image as G, ListItem as L, Mention as M, OrderedList as O, Strike as S, Underline as U, Text as a, HorizontalRule as b, BulletList as c, TaskList as d, TaskItem as e, Table as f, TableCell as g, TableHeader as h, HardBreak as i, Details as j, DetailsSummary as k, DetailsContent as l, Bold as m, Italic as n, Code as o, Link as p, Highlight as q, Subscript as r, Superscript as s, TextStyle as t, Color as u, BackgroundColor as v, FontSize as w, LineHeight as x, Paragraph as y, Heading as z };
+export type { HeadingOptions as H, ImageOptions as I, ParagraphOptions as P, TableRowOptions as T };