@prosekit/extensions 0.0.0-next-20240715071354 → 0.0.0-next-20240724155246

package/dist/_tsup-dts-rollup.d.ts

@@ -1,5 +1,6 @@
 import { AddMarkOptions } from '@prosekit/core';
-import { Attrs } from '@prosekit/pm/model';
+import { Attrs } from 'prosemirror-model';
+import { Attrs as Attrs_2 } from '@prosekit/pm/model';
 import { BundledLanguage } from 'shiki';
 import { BundledLanguageInfo } from 'shiki';
 import { bundledLanguagesInfo } from 'shiki';
@@ -12,18 +13,21 @@ import { config as default_alias_1 } from '@prosekit/dev/config-vitest';
 import { EditorState } from '@prosekit/pm/state';
 import { Extension } from '@prosekit/core';
 import { ExtensionTyping } from '@prosekit/core';
-import { ExtractMarks } from '@prosekit/core';
-import { ExtractNodes } from '@prosekit/core';
+import { ExtractMarkActions } from '@prosekit/core';
+import { ExtractNodeActions } from '@prosekit/core';
+import { GapCursor } from 'prosemirror-gapcursor';
 import { getSingletonHighlighter } from 'shiki/bundle/full';
 import type { Highlighter } from 'shiki';
 import { IndentListOptions } from 'prosemirror-flat-list';
 import { InputRule } from '@prosekit/pm/inputrules';
 import { InsertNodeOptions } from '@prosekit/core';
+import type { IsEqual } from 'type-fest';
 import { ListAttributes } from 'prosemirror-flat-list';
 import { ListDOMSerializer } from 'prosemirror-flat-list';
-import { MarkBuilder } from '@prosekit/core';
 import { MarkType } from '@prosekit/pm/model';
-import { NodeBuilder } from '@prosekit/core';
+import { Node as Node_2 } from 'prosemirror-model';
+import { NodeAction } from '@prosekit/core';
+import { NodeChild } from '@prosekit/core';
 import { NodeJSON } from '@prosekit/core';
 import { NodeType } from '@prosekit/pm/model';
 import { Options } from 'tsup';
@@ -35,11 +39,14 @@ import { RemoveMarkOptions } from '@prosekit/core';
 import { RemoveNodeOptions } from '@prosekit/core';
 import { SetBlockTypeOptions } from '@prosekit/core';
 import { SetNodeAttrsOptions } from '@prosekit/core';
+import { SimplifyDeeper } from '@prosekit/core';
 import type { SpecialLanguage } from 'shiki';
 import { StepJSON } from '@prosekit/core';
 import { TestEditor } from '@prosekit/core/test';
 import { ToggleCollapsedOptions } from 'prosemirror-flat-list';
+import { ToMarkAction } from '@prosekit/core';
 import { Transaction } from '@prosekit/pm/state';
+import { UnionExtension } from '@prosekit/core';
 import { UnsetBlockTypeOptions } from '@prosekit/core';
 import { UnsetMarkOptions } from '@prosekit/core';
 import { UnwrapListOptions } from 'prosemirror-flat-list';
@@ -48,6 +55,11 @@ import { WrapOptions } from '@prosekit/core';
 
 export declare function applyMarkRules(rules: MarkRuleOptions[], transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Transaction | null;
 
+/**
+ * Utility function assert that two types are equal in tests.
+ */
+export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
+
 declare class AutocompleteRule {
     readonly regex: RegExp;
     readonly onMatch: MatchHandler;
@@ -194,11 +206,13 @@ export declare function defineAutocomplete(rule: AutocompleteRule): Extension;
 /**
  * @public
  */
-export declare function defineBlockquote(): Extension<    {
-Nodes: "blockquote";
+export declare function defineBlockquote(): UnionExtension<readonly [Extension<    {
+Nodes: {
+blockquote: Attrs;
+};
 Marks: never;
 Commands: never;
-}>;
+}>, Extension<ExtensionTyping<any, any, any>>]>;
 
 /**
  * Wraps the text block in a blockquote when `>` is typed at the start of a new
@@ -207,7 +221,9 @@ Commands: never;
 export declare function defineBlockquoteInputRule(): Extension<ExtensionTyping<any, any, any>>;
 
 export declare function defineBlockquoteSpec(): Extension<    {
-Nodes: "blockquote";
+Nodes: {
+blockquote: Attrs;
+};
 Marks: never;
 Commands: never;
 }>;
@@ -215,13 +231,19 @@ Commands: never;
 /**
  * @public
  */
-export declare function defineBold(): Extension<    {
+export declare function defineBold(): UnionExtension<readonly [Extension<    {
+Marks: {
+bold: Attrs;
+};
 Nodes: never;
-Marks: "bold";
+Commands: never;
+}>, Extension<    {
 Commands: {
 toggleBold: [];
 };
-}>;
+Nodes: never;
+Marks: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>;
 
 export declare function defineBoldCommands(): Extension<    {
 Commands: {
@@ -236,7 +258,9 @@ export declare function defineBoldInputRule(): Extension<ExtensionTyping<any, an
 export declare function defineBoldKeymap(): Extension<ExtensionTyping<any, any, any>>;
 
 export declare function defineBoldSpec(): Extension<    {
-Marks: "bold";
+Marks: {
+bold: Attrs;
+};
 Nodes: never;
 Commands: never;
 }>;
@@ -244,13 +268,19 @@ Commands: never;
 /**
  * @public
  */
-export declare function defineCode(): Extension<    {
+export declare function defineCode(): UnionExtension<readonly [Extension<    {
+Marks: {
+code: Attrs;
+};
 Nodes: never;
-Marks: "code";
+Commands: never;
+}>, Extension<    {
 Commands: {
 toggleCode: [];
 };
-}>;
+Nodes: never;
+Marks: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>;
 
 /**
  * Adds `codeBlock` nodes to the editor. This includes the following extensions:
@@ -263,16 +293,24 @@ toggleCode: [];
  *
  * @public
  */
-declare function defineCodeBlock(): Extension<    {
-Nodes: "codeBlock";
+declare function defineCodeBlock(): UnionExtension<readonly [Extension<    {
+Nodes: {
+codeBlock: {
+language: string;
+};
+};
 Marks: never;
+Commands: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<    {
 Commands: {
 setCodeBlock: [attrs?: CodeBlockAttrs | undefined];
 insertCodeBlock: [attrs?: CodeBlockAttrs | undefined];
 toggleCodeBlock: [attrs?: CodeBlockAttrs | undefined];
 setCodeBlockAttrs: [attrs: CodeBlockAttrs];
 };
-}>;
+Nodes: never;
+Marks: never;
+}>]>;
 export { defineCodeBlock }
 export { defineCodeBlock as defineCodeBlock_alias_1 }
 
@@ -346,7 +384,11 @@ export { defineCodeBlockShiki as defineCodeBlockShiki_alias_1 }
  * @public
  */
 declare function defineCodeBlockSpec(): Extension<    {
-Nodes: "codeBlock";
+Nodes: {
+codeBlock: {
+language: string;
+};
+};
 Marks: never;
 Commands: never;
 }>;
@@ -369,7 +411,9 @@ export declare function defineCodeKeymap(): Extension<ExtensionTyping<any, any,
  * @public
  */
 export declare function defineCodeSpec(): Extension<    {
-Marks: "code";
+Marks: {
+code: Attrs;
+};
 Nodes: never;
 Commands: never;
 }>;
@@ -382,11 +426,7 @@ export declare function defineCommitRecorder(commitRecorder: CommitRecorder): Ex
 /**
  * Define an extension to display the changes from the given commit in the editor.
  */
-export declare function defineCommitViewer(commit: Commit): Extension<    {
-Nodes: never;
-Marks: never;
-Commands: never;
-}>;
+export declare function defineCommitViewer(commit: Commit): UnionExtension<readonly [Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>;
 
 /**
  * Show up a decoration at the drop position when something is dragged over the editor.
@@ -407,17 +447,41 @@ export declare function defineDropCursor(options?: DropCursorOptions): Extension
 export declare function defineEnterRule({ regex, handler, stop, }: EnterRuleOptions): Extension;
 
 /**
+ * Capture clicks near and arrow-key-motion past places that don't have a
+ * normally selectable position nearby, and create a gap cursor selection for
+ * them. The cursor is drawn as an element with class `ProseMirror-gapcursor`.
+ *
+ * You can either include `prosekit/extensions/gap-cursor.css` or add your own
+ * styles to make it visible.
+ *
+ * See
+ * [prosemirror-gapcursor](https://github.com/ProseMirror/prosemirror-gapcursor)
+ * for more information.
+ *
  * @public
  */
-export declare function defineHeading(): Extension<    {
-Nodes: "heading";
+export declare function defineGapCursor(): Extension<ExtensionTyping<any, any, any>>;
+
+/**
+ * @public
+ */
+export declare function defineHeading(): UnionExtension<readonly [Extension<    {
+Nodes: {
+heading: {
+level: number;
+};
+};
 Marks: never;
+Commands: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<    {
 Commands: {
 setHeading: [attrs?: HeadingAttrs | undefined];
 insertHeading: [attrs?: HeadingAttrs | undefined];
 toggleHeading: [attrs?: HeadingAttrs | undefined];
 };
-}>;
+Nodes: never;
+Marks: never;
+}>]>;
 
 declare function defineHeadingCommands(): Extension<    {
 Commands: {
@@ -444,7 +508,11 @@ export { defineHeadingKeymap }
 export { defineHeadingKeymap as defineHeadingKeymap_alias_1 }
 
 declare function defineHeadingSpec(): Extension<    {
-Nodes: "heading";
+Nodes: {
+heading: {
+level: number;
+};
+};
 Marks: never;
 Commands: never;
 }>;
@@ -454,13 +522,21 @@ export { defineHeadingSpec as defineHeadingSpec_alias_1 }
 /**
  * @public
  */
-export declare function defineImage(): Extension<    {
-Nodes: "image";
+export declare function defineImage(): UnionExtension<readonly [Extension<    {
+Nodes: {
+image: {
+src: null;
+};
+};
 Marks: never;
+Commands: never;
+}>, Extension<    {
 Commands: {
 insertImage: [attrs?: ImageAttrs | undefined];
 };
-}>;
+Nodes: never;
+Marks: never;
+}>]>;
 
 export declare function defineImageCommands(): Extension<    {
 Commands: {
@@ -471,7 +547,11 @@ Marks: never;
 }>;
 
 export declare function defineImageSpec(): Extension<    {
-Nodes: "image";
+Nodes: {
+image: {
+src: null;
+};
+};
 Marks: never;
 Commands: never;
 }>;
@@ -488,13 +568,19 @@ export declare function defineInputRule(rule: InputRule): Extension;
 /**
  * @public
  */
-export declare function defineItalic(): Extension<    {
+export declare function defineItalic(): UnionExtension<readonly [Extension<    {
+Marks: {
+italic: Attrs;
+};
 Nodes: never;
-Marks: "italic";
+Commands: never;
+}>, Extension<    {
 Commands: {
 toggleItalic: [];
 };
-}>;
+Nodes: never;
+Marks: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>;
 
 export declare function defineItalicCommands(): Extension<    {
 Commands: {
@@ -509,7 +595,9 @@ export declare function defineItalicInputRule(): Extension<ExtensionTyping<any,
 export declare function defineItalicKeymap(): Extension<ExtensionTyping<any, any, any>>;
 
 export declare function defineItalicSpec(): Extension<    {
-Marks: "italic";
+Marks: {
+italic: Attrs;
+};
 Nodes: never;
 Commands: never;
 }>;
@@ -517,16 +605,22 @@ Commands: never;
 /**
  * @public
  */
-export declare function defineLink(): Extension<    {
+export declare function defineLink(): UnionExtension<readonly [Extension<    {
+Marks: {
+link: LinkAttrs;
+};
 Nodes: never;
-Marks: "link";
+Commands: never;
+}>, Extension<    {
 Commands: {
 addLink: [attrs: LinkAttrs];
 removeLink: [];
 toggleLink: [attrs: LinkAttrs];
 expandLink: [];
 };
-}>;
+Nodes: never;
+Marks: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>;
 
 export declare function defineLinkCommands(): Extension<    {
 Commands: {
@@ -555,7 +649,9 @@ export declare function defineLinkInputRule(): Extension<ExtensionTyping<any, an
 export declare function defineLinkMarkRule(): Extension<ExtensionTyping<any, any, any>>;
 
 export declare function defineLinkSpec(): Extension<    {
-Marks: "link";
+Marks: {
+link: LinkAttrs;
+};
 Nodes: never;
 Commands: never;
 }>;
@@ -563,24 +659,32 @@ Commands: never;
 /**
  * @public
  */
-export declare function defineList(): Extension<{
-    Nodes: "list";
-    Marks: never;
-    Commands: {
-        dedentList: [options?: DedentListOptions | undefined];
-        indentList: [options?: IndentListOptions | undefined];
-        moveList: [direction: "up" | "down"];
-        splitList: [];
-        toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
-        toggleList: [attrs: ListAttributes];
-        unwrapList: [options?: UnwrapListOptions | undefined];
-        wrapInList: [getAttrs: WrapInListGetAttrs<ListAttributes>];
-        insertList: [attrs?: ListAttributes | undefined];
-    };
-}>;
+export declare function defineList(): UnionExtension<readonly [Extension<    {
+Nodes: {
+list: ListAttrs;
+};
+Marks: never;
+Commands: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<    {
+Commands: {
+dedentList: [options?: DedentListOptions | undefined];
+indentList: [options?: IndentListOptions | undefined];
+moveList: [direction: "up" | "down"];
+splitList: [];
+toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
+toggleList: [attrs: ListAttributes];
+unwrapList: [options?: UnwrapListOptions | undefined];
+wrapInList: [getAttrs: WrapInListGetAttrs<ListAttributes>];
+insertList: [attrs?: ListAttributes | undefined];
+};
+Nodes: never;
+Marks: never;
+}>]>;
 
 /**
- * Defines list commands
+ * Defines list commands.
+ *
+ * @internal
  */
 declare function defineListCommands(): Extension<    {
 Commands: {
@@ -600,24 +704,41 @@ Marks: never;
 export { defineListCommands }
 export { defineListCommands as defineListCommands_alias_1 }
 
-export declare function defineListInputRules(): Extension;
+/**
+ * @internal
+ */
+declare function defineListInputRules(): Extension;
+export { defineListInputRules }
+export { defineListInputRules as defineListInputRules_alias_1 }
 
 /**
  * Returns a extension that adds key bindings for list.
  *
- * @public
+ * @internal
  */
 declare function defineListKeymap(): Extension<ExtensionTyping<any, any, any>>;
 export { defineListKeymap }
 export { defineListKeymap as defineListKeymap_alias_1 }
 
-export declare function defineListPlugins(): Extension<ExtensionTyping<any, any, any>>;
+/**
+ * @internal
+ */
+declare function defineListPlugins(): Extension<ExtensionTyping<any, any, any>>;
+export { defineListPlugins }
+export { defineListPlugins as defineListPlugins_alias_1 }
 
-export declare function defineListSpec(): Extension<{
-    Nodes: "list";
-    Marks: never;
-    Commands: never;
+/**
+ * @internal
+ */
+declare function defineListSpec(): Extension<    {
+Nodes: {
+list: ListAttrs;
+};
+Marks: never;
+Commands: never;
 }>;
+export { defineListSpec }
+export { defineListSpec as defineListSpec_alias_1 }
 
 /**
  * Defines an input rule for automatically adding inline marks when a given
@@ -638,13 +759,19 @@ export { defineMarkRule as defineMarkRule_alias_1 }
 /**
  * @public
  */
-export declare function defineMention(): Extension<    {
-Nodes: "mention";
+export declare function defineMention(): UnionExtension<readonly [Extension<    {
+Nodes: {
+mention: MentionAttrs;
+};
 Marks: never;
+Commands: never;
+}>, Extension<    {
 Commands: {
 insertMention: [attrs: MentionAttrs];
 };
-}>;
+Nodes: never;
+Marks: never;
+}>]>;
 
 export declare function defineMentionCommands(): Extension<    {
 Commands: {
@@ -658,7 +785,9 @@ Marks: never;
  * @public
  */
 export declare function defineMentionSpec(): Extension<    {
-Nodes: "mention";
+Nodes: {
+mention: MentionAttrs;
+};
 Marks: never;
 Commands: never;
 }>;
@@ -712,13 +841,19 @@ export declare function defineSearchQuery(options: SearchQueryOptions): Extensio
 /**
  * @public
  */
-export declare function defineStrike(): Extension<    {
+export declare function defineStrike(): UnionExtension<readonly [Extension<    {
+Marks: {
+strike: Attrs;
+};
 Nodes: never;
-Marks: "strike";
+Commands: never;
+}>, Extension<    {
 Commands: {
 toggleStrike: [];
 };
-}>;
+Nodes: never;
+Marks: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>;
 
 export declare function defineStrikeCommands(): Extension<    {
 Commands: {
@@ -733,7 +868,9 @@ export declare function defineStrikeInputRule(): Extension<ExtensionTyping<any,
 export declare function defineStrikeKeymap(): Extension<ExtensionTyping<any, any, any>>;
 
 export declare function defineStrikeSpec(): Extension<    {
-Marks: "strike";
+Marks: {
+strike: Attrs;
+};
 Nodes: never;
 Commands: never;
 }>;
@@ -741,9 +878,35 @@ Commands: never;
 /**
  * @public
  */
-export declare function defineTable(): Extension<    {
-Nodes: "table" | "tableRow" | "tableCell" | "tableHeaderCell";
+export declare function defineTable(): UnionExtension<readonly [Extension<    {
+Nodes: {
+table: Attrs;
+};
 Marks: never;
+Commands: never;
+}>, Extension<    {
+Nodes: {
+tableRow: Attrs;
+};
+Marks: never;
+Commands: never;
+}>, Extension<    {
+Nodes: {
+tableCell: {
+[x: string]: any;
+};
+};
+Marks: never;
+Commands: never;
+}>, Extension<    {
+Nodes: {
+tableHeaderCell: {
+[x: string]: any;
+};
+};
+Marks: never;
+Commands: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<    {
 Commands: {
 insertTable: [{
 row: number;
@@ -752,10 +915,16 @@ header: boolean;
 }];
 exitTable: [];
 };
-}>;
+Nodes: never;
+Marks: never;
+}>]>;
 
 declare function defineTableCellSpec(): Extension<    {
-Nodes: "tableCell";
+Nodes: {
+tableCell: {
+[x: string]: any;
+};
+};
 Marks: never;
 Commands: never;
 }>;
@@ -783,7 +952,11 @@ export { defineTableCommands }
 export { defineTableCommands as defineTableCommands_alias_1 }
 
 declare function defineTableHeaderCellSpec(): Extension<    {
-Nodes: "tableHeaderCell";
+Nodes: {
+tableHeaderCell: {
+[x: string]: any;
+};
+};
 Marks: never;
 Commands: never;
 }>;
@@ -798,7 +971,9 @@ export { defineTablePlugins }
 export { defineTablePlugins as defineTablePlugins_alias_1 }
 
 declare function defineTableRowSpec(): Extension<    {
-Nodes: "tableRow";
+Nodes: {
+tableRow: Attrs_2;
+};
 Marks: never;
 Commands: never;
 }>;
@@ -806,7 +981,9 @@ export { defineTableRowSpec }
 export { defineTableRowSpec as defineTableRowSpec_alias_1 }
 
 declare function defineTableSpec(): Extension<    {
-Nodes: "table";
+Nodes: {
+table: Attrs_2;
+};
 Marks: never;
 Commands: never;
 }>;
@@ -816,57 +993,222 @@ export { defineTableSpec as defineTableSpec_alias_1 }
 /**
  * @internal
  */
-export declare function defineTestExtension(): Extension<{
-    Nodes: "blockquote" | "table" | "text" | "doc" | "paragraph" | "heading" | "image" | "list" | "tableRow" | "tableCell" | "tableHeaderCell";
-    Marks: "code" | "link" | "bold" | "strike" | "italic" | "underline";
-    Commands: {
-        insertText: [{
-            text: string;
-            from?: number;
-            to?: number;
-        }];
-        insertNode: [options: InsertNodeOptions];
-        removeNode: [options: RemoveNodeOptions];
-        wrap: [WrapOptions];
-        setBlockType: [options: SetBlockTypeOptions];
-        setNodeAttrs: [options: SetNodeAttrsOptions];
-        selectAll: [];
-        addMark: [options: AddMarkOptions];
-        removeMark: [options: RemoveMarkOptions];
-        unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
-        unsetMark: [options?: UnsetMarkOptions | undefined];
-        readonly undo: [];
-        readonly redo: [];
-        toggleBold: [];
-        toggleCode: [];
-        setHeading: [attrs?: HeadingAttrs | undefined];
-        insertHeading: [attrs?: HeadingAttrs | undefined];
-        toggleHeading: [attrs?: HeadingAttrs | undefined];
-        insertImage: [attrs?: ImageAttrs | undefined];
-        toggleItalic: [];
-        addLink: [attrs: LinkAttrs];
-        removeLink: [];
-        toggleLink: [attrs: LinkAttrs];
-        expandLink: [];
-        dedentList: [options?: DedentListOptions | undefined];
-        indentList: [options?: IndentListOptions | undefined];
-        moveList: [direction: "up" | "down"];
-        splitList: [];
-        toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
-        toggleList: [attrs: ListAttributes];
-        unwrapList: [options?: UnwrapListOptions | undefined];
-        wrapInList: [getAttrs: WrapInListGetAttrs<ListAttributes>];
-        insertList: [attrs?: ListAttributes | undefined];
-        toggleStrike: [];
-        insertTable: [{
-            row: number;
-            col: number;
-            header: boolean;
-        }];
-        exitTable: [];
-        toggleUnderline: [];
-    };
-}>;
+export declare function defineTestExtension(): UnionExtension<readonly [Extension<{
+Nodes: {
+doc: Attrs;
+};
+Marks: never;
+Commands: never;
+}>, Extension<{
+Nodes: {
+text: Attrs;
+};
+Marks: never;
+Commands: never;
+}>, UnionExtension<readonly [Extension<{
+Nodes: {
+heading: {
+level: number;
+};
+};
+Marks: never;
+Commands: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<{
+Commands: {
+setHeading: [attrs?: HeadingAttrs | undefined];
+insertHeading: [attrs?: HeadingAttrs | undefined];
+toggleHeading: [attrs?: HeadingAttrs | undefined];
+};
+Nodes: never;
+Marks: never;
+}>]>, UnionExtension<readonly [Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<{
+Commands: {
+readonly undo: [];
+readonly redo: [];
+};
+Nodes: never;
+Marks: never;
+}>]>, UnionExtension<readonly [Extension<{
+Nodes: {
+list: ListAttrs;
+};
+Marks: never;
+Commands: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<{
+Commands: {
+dedentList: [options?: DedentListOptions | undefined];
+indentList: [options?: IndentListOptions | undefined];
+moveList: [direction: "up" | "down"];
+splitList: [];
+toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
+toggleList: [attrs: ListAttributes];
+unwrapList: [options?: UnwrapListOptions | undefined];
+wrapInList: [getAttrs: WrapInListGetAttrs<ListAttributes>];
+insertList: [attrs?: ListAttributes | undefined];
+};
+Nodes: never;
+Marks: never;
+}>]>, UnionExtension<readonly [Extension<{
+Nodes: {
+blockquote: Attrs;
+};
+Marks: never;
+Commands: never;
+}>, Extension<ExtensionTyping<any, any, any>>]>, Extension<ExtensionTyping<any, any, any>>, Extension<{
+Commands: {
+insertText: [{
+text: string;
+from?: number;
+to?: number;
+}];
+insertNode: [options: InsertNodeOptions];
+removeNode: [options: RemoveNodeOptions];
+wrap: [WrapOptions];
+setBlockType: [options: SetBlockTypeOptions];
+setNodeAttrs: [options: SetNodeAttrsOptions];
+selectAll: [];
+addMark: [options: AddMarkOptions];
+removeMark: [options: RemoveMarkOptions];
+unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
+unsetMark: [options?: UnsetMarkOptions | undefined];
+};
+Nodes: never;
+Marks: never;
+}>, UnionExtension<readonly [Extension<{
+Marks: {
+italic: Attrs;
+};
+Nodes: never;
+Commands: never;
+}>, Extension<{
+Commands: {
+toggleItalic: [];
+};
+Nodes: never;
+Marks: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>, UnionExtension<readonly [Extension<{
+Marks: {
+bold: Attrs;
+};
+Nodes: never;
+Commands: never;
+}>, Extension<{
+Commands: {
+toggleBold: [];
+};
+Nodes: never;
+Marks: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>, UnionExtension<readonly [Extension<{
+Marks: {
+underline: Attrs;
+};
+Nodes: never;
+Commands: never;
+}>, Extension<{
+Commands: {
+toggleUnderline: [];
+};
+Nodes: never;
+Marks: never;
+}>, Extension<ExtensionTyping<any, any, any>>]>, UnionExtension<readonly [Extension<{
+Marks: {
+strike: Attrs;
+};
+Nodes: never;
+Commands: never;
+}>, Extension<{
+Commands: {
+toggleStrike: [];
+};
+Nodes: never;
+Marks: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>, UnionExtension<readonly [Extension<{
+Marks: {
+code: Attrs;
+};
+Nodes: never;
+Commands: never;
+}>, Extension<{
+Commands: {
+toggleCode: [];
+};
+Nodes: never;
+Marks: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>, UnionExtension<readonly [Extension<{
+Marks: {
+link: LinkAttrs;
+};
+Nodes: never;
+Commands: never;
+}>, Extension<{
+Commands: {
+addLink: [attrs: LinkAttrs];
+removeLink: [];
+toggleLink: [attrs: LinkAttrs];
+expandLink: [];
+};
+Nodes: never;
+Marks: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>, UnionExtension<readonly [Extension<{
+Nodes: {
+image: {
+src: null;
+};
+};
+Marks: never;
+Commands: never;
+}>, Extension<{
+Commands: {
+insertImage: [attrs?: ImageAttrs | undefined];
+};
+Nodes: never;
+Marks: never;
+}>]>, Extension<{
+Nodes: {
+paragraph: Attrs;
+};
+Marks: never;
+Commands: never;
+}>, UnionExtension<readonly [Extension<{
+Nodes: {
+table: Attrs;
+};
+Marks: never;
+Commands: never;
+}>, Extension<{
+Nodes: {
+tableRow: Attrs;
+};
+Marks: never;
+Commands: never;
+}>, Extension<{
+Nodes: {
+tableCell: {
+[x: string]: any;
+};
+};
+Marks: never;
+Commands: never;
+}>, Extension<{
+Nodes: {
+tableHeaderCell: {
+[x: string]: any;
+};
+};
+Marks: never;
+Commands: never;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<{
+Commands: {
+insertTable: [{
+row: number;
+col: number;
+header: boolean;
+}];
+exitTable: [];
+};
+Nodes: never;
+Marks: never;
+}>]>]>;
 
 /**
  * Adds a `textAlign` attribute to the specified nodes. This will be rendered as
@@ -874,23 +1216,23 @@ export declare function defineTestExtension(): Extension<{
  *
  * @public
  */
-export declare function defineTextAlign(options: TextAlignOptions): Extension<{
-    Nodes: never;
-    Marks: never;
-    Commands: {
-        setTextAlign: [value: string | null];
+export declare function defineTextAlign<NodeName extends string = string>(options: TextAlignOptions<NodeName>): Extension<{
+    Nodes: {
+        [K in NodeName]: {
+            textAlign: string | null;
+        };
     };
+    Marks: never;
+    Commands: TextAlignCommandTyping;
 }>;
 
 /**
  * @internal
  */
 export declare function defineTextAlignCommands(types: string[]): Extension<{
-    Commands: {
-        setTextAlign: [value: string | null];
-    };
     Nodes: never;
     Marks: never;
+    Commands: TextAlignCommandTyping;
 }>;
 
 /**
@@ -929,19 +1271,25 @@ export declare function defineTextBlockInputRule({ regex, type, attrs, }: {
     /**
      * Attributes to set on the node.
      */
-    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+    attrs?: Attrs_2 | null | ((match: RegExpMatchArray) => Attrs_2 | null);
 }): Extension;
 
 /**
  * @public
  */
-export declare function defineUnderline(): Extension<    {
+export declare function defineUnderline(): UnionExtension<readonly [Extension<    {
+Marks: {
+underline: Attrs;
+};
 Nodes: never;
-Marks: "underline";
+Commands: never;
+}>, Extension<    {
 Commands: {
 toggleUnderline: [];
 };
-}>;
+Nodes: never;
+Marks: never;
+}>, Extension<ExtensionTyping<any, any, any>>]>;
 
 export declare function defineUnderlineCommands(): Extension<    {
 Commands: {
@@ -954,7 +1302,9 @@ Marks: never;
 export declare function defineUnderlineKeymap(): Extension<ExtensionTyping<any, any, any>>;
 
 export declare function defineUnderlineSpec(): Extension<    {
-Marks: "underline";
+Marks: {
+underline: Attrs;
+};
 Nodes: never;
 Commands: never;
 }>;
@@ -993,7 +1343,7 @@ export declare function defineWrappingInputRule({ regex, type, attrs, join, }: {
     /**
      * Attributes to set on the node.
      */
-    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+    attrs?: Attrs_2 | null | ((match: RegExpMatchArray) => Attrs_2 | null);
     /**
      * By default, if there's a node with the same type above the newly wrapped
      * node, the rule will try to
@@ -1076,6 +1426,8 @@ export declare type EnterRuleOptions = {
  */
 export declare const exitTable: Command;
 
+export { GapCursor }
+
 export declare function getCheckRanges(transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Array<[number, number]>;
 
 export declare function getPluginState(state: EditorState): PredictionPluginState | undefined;
@@ -1144,7 +1496,31 @@ export declare interface LinkAttrs {
     href: string;
 }
 
-export { ListAttributes }
+/**
+ * The attributes of a list node.
+ *
+ * @public
+ */
+declare interface ListAttrs {
+    /**
+     * The kind of list node.
+     */
+    kind?: 'bullet' | 'ordered' | 'task' | 'toggle';
+    /**
+     * The optional order of the list node.
+     */
+    order?: number | null;
+    /**
+     * Whether the list node is checked if its `kind` is `"task"`.
+     */
+    checked?: boolean;
+    /**
+     * Whether the list node is collapsed if its `kind` is `"toggle"`.
+     */
+    collapsed?: boolean;
+}
+export { ListAttrs }
+export { ListAttrs as ListAttrs_alias_1 }
 
 export { ListDOMSerializer }
 
@@ -1167,7 +1543,7 @@ export declare interface MarkInputRuleOptions {
     /**
      * Attributes to set on the mark.
      */
-    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+    attrs?: Attrs_2 | null | ((match: RegExpMatchArray) => Attrs_2 | null);
 }
 
 /**
@@ -1191,7 +1567,7 @@ declare interface MarkRuleOptions {
      *
      * @default null
      */
-    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+    attrs?: Attrs_2 | null | ((match: RegExpMatchArray) => Attrs_2 | null);
 }
 export { MarkRuleOptions }
 export { MarkRuleOptions as MarkRuleOptions_alias_1 }
@@ -1209,8 +1585,8 @@ export { MatchHandler as MatchHandler_alias_1 }
 
 export declare interface MentionAttrs {
     id: string;
-    kind: string;
     value: string;
+    kind: string;
 }
 
 export declare interface PlaceholderOptions {
@@ -1311,59 +1687,295 @@ export declare function setTrMeta(tr: Transaction, meta: PredictionPluginState):
  * @internal
  */
 export declare function setupTest(): {
-    editor: TestEditor<Extension<{
-        Nodes: "blockquote" | "table" | "text" | "doc" | "paragraph" | "heading" | "image" | "list" | "tableRow" | "tableCell" | "tableHeaderCell";
-        Marks: "code" | "link" | "bold" | "strike" | "italic" | "underline";
-        Commands: {
-            insertText: [{
-                text: string;
-                from?: number;
-                to?: number;
-            }];
-            insertNode: [options: InsertNodeOptions];
-            removeNode: [options: RemoveNodeOptions];
-            wrap: [WrapOptions];
-            setBlockType: [options: SetBlockTypeOptions];
-            setNodeAttrs: [options: SetNodeAttrsOptions];
-            selectAll: [];
-            addMark: [options: AddMarkOptions];
-            removeMark: [options: RemoveMarkOptions];
-            unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
-            unsetMark: [options?: UnsetMarkOptions | undefined];
-            readonly undo: [];
-            readonly redo: [];
-            toggleBold: [];
-            toggleCode: [];
-            setHeading: [attrs?: HeadingAttrs | undefined];
-            insertHeading: [attrs?: HeadingAttrs | undefined];
-            toggleHeading: [attrs?: HeadingAttrs | undefined];
-            insertImage: [attrs?: ImageAttrs | undefined];
-            toggleItalic: [];
-            addLink: [attrs: LinkAttrs];
-            removeLink: [];
-            toggleLink: [attrs: LinkAttrs];
-            expandLink: [];
-            dedentList: [options?: DedentListOptions | undefined];
-            indentList: [options?: IndentListOptions | undefined];
-            moveList: [direction: "up" | "down"];
-            splitList: [];
-            toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
-            toggleList: [attrs: ListAttributes];
-            unwrapList: [options?: UnwrapListOptions | undefined];
-            wrapInList: [getAttrs: WrapInListGetAttrs<ListAttributes>];
-            insertList: [attrs?: ListAttributes | undefined];
-            toggleStrike: [];
-            insertTable: [{
-                row: number;
-                col: number;
-                header: boolean;
-            }];
-            exitTable: [];
-            toggleUnderline: [];
-        };
+    editor: TestEditor<UnionExtension<readonly [Extension<{
+    Nodes: {
+    doc: Attrs;
+    };
+    Marks: never;
+    Commands: never;
+    }>, Extension<{
+    Nodes: {
+    text: Attrs;
+    };
+    Marks: never;
+    Commands: never;
+    }>, UnionExtension<readonly [Extension<{
+    Nodes: {
+    heading: {
+    level: number;
+    };
+    };
+    Marks: never;
+    Commands: never;
+    }>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<{
+    Commands: {
+    setHeading: [attrs?: HeadingAttrs | undefined];
+    insertHeading: [attrs?: HeadingAttrs | undefined];
+    toggleHeading: [attrs?: HeadingAttrs | undefined];
+    };
+    Nodes: never;
+    Marks: never;
+    }>]>, UnionExtension<readonly [Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<{
+    Commands: {
+    readonly undo: [];
+    readonly redo: [];
+    };
+    Nodes: never;
+    Marks: never;
+    }>]>, UnionExtension<readonly [Extension<{
+    Nodes: {
+    list: ListAttrs;
+    };
+    Marks: never;
+    Commands: never;
+    }>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<{
+    Commands: {
+    dedentList: [options?: DedentListOptions | undefined];
+    indentList: [options?: IndentListOptions | undefined];
+    moveList: [direction: "up" | "down"];
+    splitList: [];
+    toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
+    toggleList: [attrs: ListAttributes];
+    unwrapList: [options?: UnwrapListOptions | undefined];
+    wrapInList: [getAttrs: WrapInListGetAttrs<ListAttributes>];
+    insertList: [attrs?: ListAttributes | undefined];
+    };
+    Nodes: never;
+    Marks: never;
+    }>]>, UnionExtension<readonly [Extension<{
+    Nodes: {
+    blockquote: Attrs;
+    };
+    Marks: never;
+    Commands: never;
+    }>, Extension<ExtensionTyping<any, any, any>>]>, Extension<ExtensionTyping<any, any, any>>, Extension<{
+    Commands: {
+    insertText: [{
+    text: string;
+    from?: number;
+    to?: number;
+    }];
+    insertNode: [options: InsertNodeOptions];
+    removeNode: [options: RemoveNodeOptions];
+    wrap: [WrapOptions];
+    setBlockType: [options: SetBlockTypeOptions];
+    setNodeAttrs: [options: SetNodeAttrsOptions];
+    selectAll: [];
+    addMark: [options: AddMarkOptions];
+    removeMark: [options: RemoveMarkOptions];
+    unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
+    unsetMark: [options?: UnsetMarkOptions | undefined];
+    };
+    Nodes: never;
+    Marks: never;
+    }>, UnionExtension<readonly [Extension<{
+    Marks: {
+    italic: Attrs;
+    };
+    Nodes: never;
+    Commands: never;
+    }>, Extension<{
+    Commands: {
+    toggleItalic: [];
+    };
+    Nodes: never;
+    Marks: never;
+    }>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>, UnionExtension<readonly [Extension<{
+    Marks: {
+    bold: Attrs;
+    };
+    Nodes: never;
+    Commands: never;
+    }>, Extension<{
+    Commands: {
+    toggleBold: [];
+    };
+    Nodes: never;
+    Marks: never;
+    }>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>, UnionExtension<readonly [Extension<{
+    Marks: {
+    underline: Attrs;
+    };
+    Nodes: never;
+    Commands: never;
+    }>, Extension<{
+    Commands: {
+    toggleUnderline: [];
+    };
+    Nodes: never;
+    Marks: never;
+    }>, Extension<ExtensionTyping<any, any, any>>]>, UnionExtension<readonly [Extension<{
+    Marks: {
+    strike: Attrs;
+    };
+    Nodes: never;
+    Commands: never;
+    }>, Extension<{
+    Commands: {
+    toggleStrike: [];
+    };
+    Nodes: never;
+    Marks: never;
+    }>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>, UnionExtension<readonly [Extension<{
+    Marks: {
+    code: Attrs;
+    };
+    Nodes: never;
+    Commands: never;
+    }>, Extension<{
+    Commands: {
+    toggleCode: [];
+    };
+    Nodes: never;
+    Marks: never;
+    }>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>, UnionExtension<readonly [Extension<{
+    Marks: {
+    link: LinkAttrs;
+    };
+    Nodes: never;
+    Commands: never;
+    }>, Extension<{
+    Commands: {
+    addLink: [attrs: LinkAttrs];
+    removeLink: [];
+    toggleLink: [attrs: LinkAttrs];
+    expandLink: [];
+    };
+    Nodes: never;
+    Marks: never;
+    }>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>]>, UnionExtension<readonly [Extension<{
+    Nodes: {
+    image: {
+    src: null;
+    };
+    };
+    Marks: never;
+    Commands: never;
+    }>, Extension<{
+    Commands: {
+    insertImage: [attrs?: ImageAttrs | undefined];
+    };
+    Nodes: never;
+    Marks: never;
+    }>]>, Extension<{
+    Nodes: {
+    paragraph: Attrs;
+    };
+    Marks: never;
+    Commands: never;
+    }>, UnionExtension<readonly [Extension<{
+    Nodes: {
+    table: Attrs;
+    };
+    Marks: never;
+    Commands: never;
+    }>, Extension<{
+    Nodes: {
+    tableRow: Attrs;
+    };
+    Marks: never;
+    Commands: never;
+    }>, Extension<{
+    Nodes: {
+    tableCell: {
+    [x: string]: any;
+    };
+    };
+    Marks: never;
+    Commands: never;
+    }>, Extension<{
+    Nodes: {
+    tableHeaderCell: {
+    [x: string]: any;
+    };
+    };
+    Marks: never;
+    Commands: never;
+    }>, Extension<ExtensionTyping<any, any, any>>, Extension<{
+    Commands: {
+    insertTable: [{
+    row: number;
+    col: number;
+    header: boolean;
+    }];
+    exitTable: [];
+    };
+    Nodes: never;
+    Marks: never;
+    }>]>]>>;
+    m: ToMarkAction<SimplifyDeeper<    {
+    underline: {
+    readonly [x: string]: any;
+    };
+    strike: {
+    readonly [x: string]: any;
+    };
+    link: {
+    href: string;
+    };
+    italic: {
+    readonly [x: string]: any;
+    };
+    code: {
+    readonly [x: string]: any;
+    };
+    bold: {
+    readonly [x: string]: any;
+    };
     }>>;
-    n: Record<"blockquote" | "table" | "text" | "doc" | "paragraph" | "heading" | "image" | "list" | "tableRow" | "tableCell" | "tableHeaderCell", NodeBuilder>;
-    m: Record<"code" | "link" | "bold" | "strike" | "italic" | "underline", MarkBuilder>;
+    n: {
+        p: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        h1: (...children: NodeChild[]) => Node_2;
+        h2: (...children: NodeChild[]) => Node_2;
+        h3: (...children: NodeChild[]) => Node_2;
+        h4: (...children: NodeChild[]) => Node_2;
+        h5: (...children: NodeChild[]) => Node_2;
+        h6: (...children: NodeChild[]) => Node_2;
+        bullet: (...children: NodeChild[]) => Node_2;
+        ordered: (...children: NodeChild[]) => Node_2;
+        checked: (...children: NodeChild[]) => Node_2;
+        unchecked: (...children: NodeChild[]) => Node_2;
+        collapsed: (...children: NodeChild[]) => Node_2;
+        expanded: (...children: NodeChild[]) => Node_2;
+        paragraph: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        tableHeaderCell: NodeAction<    {
+        [x: string]: any;
+        }>;
+        tableCell: NodeAction<    {
+        [x: string]: any;
+        }>;
+        tableRow: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        table: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        list: NodeAction<    {
+        kind?: "bullet" | "ordered" | "task" | "toggle";
+        order?: number | null;
+        checked?: boolean;
+        collapsed?: boolean;
+        }>;
+        image: NodeAction<    {
+        src: null;
+        }>;
+        heading: NodeAction<    {
+        level: number;
+        }>;
+        blockquote: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        text: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        doc: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+    };
 };
 
 /**
@@ -1371,11 +1983,18 @@ export declare function setupTest(): {
  */
 export declare function setupTestFromExtension<E extends Extension>(extension: E): {
     editor: TestEditor<E>;
-    n: Record<ExtractNodes<E>, NodeBuilder>;
-    m: Record<ExtractMarks<E>, MarkBuilder>;
+    n: ExtractNodeActions<E>;
+    m: ExtractMarkActions<E>;
 };
 
-export declare interface TextAlignOptions {
+/**
+ * @internal
+ */
+export declare type TextAlignCommandTyping = {
+    setTextAlign: [value: string | null];
+};
+
+export declare interface TextAlignOptions<NodeName extends string = string> {
     /**
      * The names of node to add the attribute to.
      *
@@ -1383,7 +2002,7 @@ export declare interface TextAlignOptions {
      *
      * ["paragraph", "heading"]
      */
-    types: string[];
+    types: NodeName[];
     /**
      * The default value for the attribute.
      *
@@ -1410,7 +2029,7 @@ export declare type TextBlockEnterRuleOptions = {
      * Attributes to set on the node. If a function is provided, it will be called
      * with the matched result from the regular expression.
      */
-    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+    attrs?: Attrs_2 | null | ((match: RegExpMatchArray) => Attrs_2 | null);
     /**
      * Whether to stop further handlers from being called if this rule is triggered.
      *