@prosekit/extensions 0.7.5 → 0.7.7

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

@@ -1,6 +1,6 @@
-import { AddMarkOptions } from '@prosekit/core';
-import { Attrs } from 'prosemirror-model';
-import { Attrs as Attrs_2 } from '@prosekit/pm/model';
+import { Attrs } from '@prosekit/pm/model';
+import { Attrs as Attrs_2 } from 'prosemirror-model';
+import { BaseCommandsExtension } from '@prosekit/core';
 import { BundledLanguage } from 'shiki';
 import { BundledLanguageInfo } from 'shiki';
 import { bundledLanguagesInfo } from 'shiki';
@@ -10,18 +10,20 @@ import { bundledThemesInfo } from 'shiki';
 import { Command } from '@prosekit/pm/state';
 import { DedentListOptions } from 'prosemirror-flat-list';
 import { config as default_alias_1 } from '@prosekit/dev/config-vitest';
+import { DocExtension } from '@prosekit/core';
 import { EditorState } from '@prosekit/pm/state';
 import { Extension } from '@prosekit/core';
 import { ExtensionTyping } 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 { HistoryExtension } from '@prosekit/core';
 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 type { ListAttributes } from 'prosemirror-flat-list';
 import { ListDOMSerializer } from 'prosemirror-flat-list';
 import { MarkType } from '@prosekit/pm/model';
 import { Node as Node_2 } from 'prosemirror-model';
@@ -31,25 +33,21 @@ import { NodeJSON } from '@prosekit/core';
 import { NodeType } from '@prosekit/pm/model';
 import { Options } from 'tsup';
 import { Parser } from 'prosemirror-highlight';
+import { PlainExtension } from '@prosekit/core';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
 import { PluginKey } from '@prosekit/pm/state';
 import { ProseMirrorNode } from '@prosekit/pm/model';
-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 { TextExtension } from '@prosekit/core';
 import { ToggleCollapsedOptions } from 'prosemirror-flat-list';
 import { ToMarkAction } from '@prosekit/core';
 import { Transaction } from '@prosekit/pm/state';
-import { UnsetBlockTypeOptions } from '@prosekit/core';
-import { UnsetMarkOptions } from '@prosekit/core';
+import { Union } from '@prosekit/core';
 import { UnwrapListOptions } from 'prosemirror-flat-list';
 import { WrapInListGetAttrs } from 'prosemirror-flat-list';
-import { WrapOptions } from '@prosekit/core';
 
 export declare function applyMarkRules(rules: MarkRuleOptions[], transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Transaction | null;
 
@@ -77,6 +75,43 @@ declare class AutocompleteRule {
 export { AutocompleteRule }
 export { AutocompleteRule as AutocompleteRule_alias_1 }
 
+/**
+ * @internal
+ */
+export declare type BlockquoteExtension = Union<[BlockquoteSpecExtension]>;
+
+/**
+ * @internal
+ */
+export declare type BlockquoteSpecExtension = Extension<{
+    Nodes: {
+        blockquote: Attrs;
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type BoldCommandsExtension = Extension<{
+    Commands: {
+        toggleBold: [];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type BoldExtension = Union<[BoldSpecExtension, BoldCommandsExtension]>;
+
+/**
+ * @internal
+ */
+export declare type BoldSpecExtension = Extension<{
+    Marks: {
+        bold: Attrs;
+    };
+}>;
+
 export { BundledLanguage as ShikiBundledLanguage }
 export { BundledLanguage as ShikiBundledLanguage_alias_1 }
 
@@ -95,6 +130,9 @@ export { BundledThemeInfo as ShikiBundledThemeInfo_alias_1 }
 export { bundledThemesInfo as shikiBundledThemesInfo }
 export { bundledThemesInfo as shikiBundledThemesInfo_alias_1 }
 
+/**
+ * @public
+ */
 export declare interface CellAttrs {
     colspan: number;
     rowspan: number;
@@ -107,11 +145,35 @@ export declare interface CellAttrs {
  * @public
  */
 declare interface CodeBlockAttrs {
-    language?: string;
+    language: string;
 }
 export { CodeBlockAttrs }
 export { CodeBlockAttrs as CodeBlockAttrs_alias_1 }
 
+/**
+ * @internal
+ */
+declare type CodeBlockCommandsExtension = Extension<{
+    Commands: {
+        setCodeBlock: [attrs?: CodeBlockAttrs];
+        insertCodeBlock: [attrs?: CodeBlockAttrs];
+        toggleCodeBlock: [attrs?: CodeBlockAttrs];
+        setCodeBlockAttrs: [attrs: CodeBlockAttrs];
+    };
+}>;
+export { CodeBlockCommandsExtension }
+export { CodeBlockCommandsExtension as CodeBlockCommandsExtension_alias_1 }
+
+/**
+ * @internal
+ */
+declare type CodeBlockExtension = Union<[
+CodeBlockSpecExtension,
+CodeBlockCommandsExtension
+]>;
+export { CodeBlockExtension }
+export { CodeBlockExtension as CodeBlockExtension_alias_1 }
+
 /**
  * @public
  */
@@ -137,6 +199,40 @@ export declare interface CodeBlockShikiOptions {
     langAlias?: Record<string, BundledLanguage>;
 }
 
+/**
+ * @internal
+ */
+declare type CodeBlockSpecExtension = Extension<{
+    Nodes: {
+        codeBlock: CodeBlockAttrs;
+    };
+}>;
+export { CodeBlockSpecExtension }
+export { CodeBlockSpecExtension as CodeBlockSpecExtension_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type CodeCommandsExtension = Extension<{
+    Commands: {
+        toggleCode: [];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type CodeExtension = Union<[CodeSpecExtension, CodeCommandsExtension]>;
+
+/**
+ * @internal
+ */
+export declare type CodeSpecExtension = Extension<{
+    Marks: {
+        code: Attrs;
+    };
+}>;
+
 /**
  * A JSON representation of a commit.
  */
@@ -204,73 +300,45 @@ export declare function defineAutocomplete(rule: AutocompleteRule): Extension;
 /**
  * @public
  */
-export declare function defineBlockquote(): Extension<    {
-Nodes: SimplifyDeeper<    {
-blockquote: Attrs;
-}>;
-Marks: never;
-Commands: never;
-}>;
+export declare function defineBlockquote(): BlockquoteExtension;
 
 /**
  * Wraps the text block in a blockquote when `>` is typed at the start of a new
  * line followed by a space.
  */
-export declare function defineBlockquoteInputRule(): Extension<ExtensionTyping<any, any, any>>;
+export declare function defineBlockquoteInputRule(): PlainExtension;
 
-export declare function defineBlockquoteSpec(): Extension<    {
-Nodes: {
-blockquote: Attrs;
-};
-Marks: never;
-Commands: never;
-}>;
+export declare function defineBlockquoteSpec(): BlockquoteSpecExtension;
 
 /**
  * @public
  */
-export declare function defineBold(): Extension<    {
-Nodes: never;
-Marks: SimplifyDeeper<    {
-bold: Attrs;
-}>;
-Commands: {
-toggleBold: [];
-};
-}>;
+export declare function defineBold(): BoldExtension;
 
-export declare function defineBoldCommands(): Extension<    {
-Commands: {
-toggleBold: [];
-};
-Nodes: never;
-Marks: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineBoldCommands(): BoldCommandsExtension;
 
-export declare function defineBoldInputRule(): Extension<ExtensionTyping<any, any, any>>;
+/**
+ * @internal
+ */
+export declare function defineBoldInputRule(): PlainExtension;
 
-export declare function defineBoldKeymap(): Extension<ExtensionTyping<any, any, any>>;
+/**
+ * @internal
+ */
+export declare function defineBoldKeymap(): PlainExtension;
 
-export declare function defineBoldSpec(): Extension<    {
-Marks: {
-bold: Attrs;
-};
-Nodes: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineBoldSpec(): BoldSpecExtension;
 
 /**
  * @public
  */
-export declare function defineCode(): Extension<    {
-Nodes: never;
-Marks: SimplifyDeeper<    {
-code: Attrs;
-}>;
-Commands: {
-toggleCode: [];
-};
-}>;
+export declare function defineCode(): CodeExtension;
 
 /**
  * Adds `codeBlock` nodes to the editor. This includes the following extensions:
@@ -283,20 +351,7 @@ toggleCode: [];
  *
  * @public
  */
-declare function defineCodeBlock(): Extension<    {
-Nodes: SimplifyDeeper<    {
-codeBlock: {
-language: string;
-};
-}>;
-Marks: never;
-Commands: {
-setCodeBlock: [attrs?: CodeBlockAttrs | undefined];
-insertCodeBlock: [attrs?: CodeBlockAttrs | undefined];
-toggleCodeBlock: [attrs?: CodeBlockAttrs | undefined];
-setCodeBlockAttrs: [attrs: CodeBlockAttrs];
-};
-}>;
+declare function defineCodeBlock(): CodeBlockExtension;
 export { defineCodeBlock }
 export { defineCodeBlock as defineCodeBlock_alias_1 }
 
@@ -305,16 +360,7 @@ export { defineCodeBlock as defineCodeBlock_alias_1 }
  *
  * @public
  */
-declare function defineCodeBlockCommands(): Extension<    {
-Commands: {
-setCodeBlock: [attrs?: CodeBlockAttrs | undefined];
-insertCodeBlock: [attrs?: CodeBlockAttrs | undefined];
-toggleCodeBlock: [attrs?: CodeBlockAttrs | undefined];
-setCodeBlockAttrs: [attrs: CodeBlockAttrs];
-};
-Nodes: never;
-Marks: never;
-}>;
+declare function defineCodeBlockCommands(): CodeBlockCommandsExtension;
 export { defineCodeBlockCommands }
 export { defineCodeBlockCommands as defineCodeBlockCommands_alias_1 }
 
@@ -323,7 +369,7 @@ export { defineCodeBlockCommands as defineCodeBlockCommands_alias_1 }
  *
  * @public
  */
-declare function defineCodeBlockEnterRule(): Extension<ExtensionTyping<any, any, any>>;
+declare function defineCodeBlockEnterRule(): PlainExtension;
 export { defineCodeBlockEnterRule }
 export { defineCodeBlockEnterRule as defineCodeBlockEnterRule_alias_1 }
 
@@ -346,14 +392,14 @@ export { defineCodeBlockHighlight as defineCodeBlockHighlight_alias_1 }
  *
  * @public
  */
-declare function defineCodeBlockInputRule(): Extension<ExtensionTyping<any, any, any>>;
+declare function defineCodeBlockInputRule(): PlainExtension;
 export { defineCodeBlockInputRule }
 export { defineCodeBlockInputRule as defineCodeBlockInputRule_alias_1 }
 
 /**
  * Defines the keymap for code blocks.
  */
-export declare function defineCodeBlockKeymap(): Extension<ExtensionTyping<any, any, any>>;
+export declare function defineCodeBlockKeymap(): PlainExtension;
 
 /**
  * Adds syntax highlighting to code blocks using the [shiki](https://github.com/shikijs/shiki) package.
@@ -369,54 +415,39 @@ export { defineCodeBlockShiki as defineCodeBlockShiki_alias_1 }
  *
  * @public
  */
-declare function defineCodeBlockSpec(): Extension<    {
-Nodes: {
-codeBlock: {
-language: string;
-};
-};
-Marks: never;
-Commands: never;
-}>;
+declare function defineCodeBlockSpec(): CodeBlockSpecExtension;
 export { defineCodeBlockSpec }
 export { defineCodeBlockSpec as defineCodeBlockSpec_alias_1 }
 
-export declare function defineCodeCommands(): Extension<    {
-Commands: {
-toggleCode: [];
-};
-Nodes: never;
-Marks: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineCodeCommands(): CodeCommandsExtension;
 
-export declare function defineCodeInputRule(): Extension<ExtensionTyping<any, any, any>>;
+/**
+ * @internal
+ */
+export declare function defineCodeInputRule(): PlainExtension;
 
-export declare function defineCodeKeymap(): Extension<ExtensionTyping<any, any, any>>;
+/**
+ * @internal
+ */
+export declare function defineCodeKeymap(): PlainExtension;
 
 /**
- * @public
+ * @internal
  */
-export declare function defineCodeSpec(): Extension<    {
-Marks: {
-code: Attrs;
-};
-Nodes: never;
-Commands: never;
-}>;
+export declare function defineCodeSpec(): CodeSpecExtension;
 
 /**
  * Define an extension that can record the changes in the editor.
  */
-export declare function defineCommitRecorder(commitRecorder: CommitRecorder): Extension<ExtensionTyping<any, any, any>>;
+export declare function defineCommitRecorder(commitRecorder: CommitRecorder): PlainExtension;
 
 /**
  * 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): PlainExtension;
 
 /**
  * Show up a decoration at the drop position when something is dragged over the editor.
@@ -425,7 +456,7 @@ Commands: never;
  *
  * @public
  */
-export declare function defineDropCursor(options?: DropCursorOptions): Extension<ExtensionTyping<any, any, any>>;
+export declare function defineDropCursor(options?: DropCursorOptions): DropCursorExtension;
 
 /**
  * Defines an enter rule. An enter rule applies when the text directly in front of
@@ -434,93 +465,74 @@ export declare function defineDropCursor(options?: DropCursorOptions): Extension
  *
  * @public
  */
-export declare function defineEnterRule({ regex, handler, stop, }: EnterRuleOptions): Extension;
+export declare function defineEnterRule(options: EnterRuleOptions): PlainExtension;
 
 /**
+ * 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: SimplifyDeeper<    {
-heading: {
-level: number;
-};
-}>;
-Marks: never;
-Commands: {
-setHeading: [attrs?: HeadingAttrs | undefined];
-insertHeading: [attrs?: HeadingAttrs | undefined];
-toggleHeading: [attrs?: HeadingAttrs | undefined];
-};
-}>;
+export declare function defineGapCursor(): GapCursorExtension;
 
-declare function defineHeadingCommands(): Extension<    {
-Commands: {
-setHeading: [attrs?: HeadingAttrs | undefined];
-insertHeading: [attrs?: HeadingAttrs | undefined];
-toggleHeading: [attrs?: HeadingAttrs | undefined];
-};
-Nodes: never;
-Marks: never;
-}>;
+/**
+ * @public
+ */
+export declare function defineHeading(): HeadingExtension;
+
+/**
+ * @internal
+ */
+declare function defineHeadingCommands(): HeadingCommandsExtension;
 export { defineHeadingCommands }
 export { defineHeadingCommands as defineHeadingCommands_alias_1 }
 
 /**
  * Converts the text block to a heading when `#` is typed at the start of a new
  * line followed by a space.
+ *
+ * @internal
  */
-declare function defineHeadingInputRule(): Extension<ExtensionTyping<any, any, any>>;
+declare function defineHeadingInputRule(): PlainExtension;
 export { defineHeadingInputRule }
 export { defineHeadingInputRule as defineHeadingInputRule_alias_1 }
 
-declare function defineHeadingKeymap(): Extension<ExtensionTyping<any, any, any>>;
+/**
+ * @internal
+ */
+declare function defineHeadingKeymap(): PlainExtension;
 export { defineHeadingKeymap }
 export { defineHeadingKeymap as defineHeadingKeymap_alias_1 }
 
-declare function defineHeadingSpec(): Extension<    {
-Nodes: {
-heading: {
-level: number;
-};
-};
-Marks: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+declare function defineHeadingSpec(): HeadingSpecExtension;
 export { defineHeadingSpec }
 export { defineHeadingSpec as defineHeadingSpec_alias_1 }
 
 /**
  * @public
  */
-export declare function defineImage(): Extension<    {
-Nodes: SimplifyDeeper<    {
-image: {
-src: null;
-};
-}>;
-Marks: never;
-Commands: {
-insertImage: [attrs?: ImageAttrs | undefined];
-};
-}>;
+export declare function defineImage(): ImageExtension;
 
-export declare function defineImageCommands(): Extension<    {
-Commands: {
-insertImage: [attrs?: ImageAttrs | undefined];
-};
-Nodes: never;
-Marks: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineImageCommands(): ImageCommandsExtension;
 
-export declare function defineImageSpec(): Extension<    {
-Nodes: {
-image: {
-src: null;
-};
-};
-Marks: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineImageSpec(): ImageSpecExtension;
 
 /**
  * Defines an input rule extension.
@@ -529,132 +541,77 @@ Commands: never;
  *
  * @public
  */
-export declare function defineInputRule(rule: InputRule): Extension;
+export declare function defineInputRule(rule: InputRule): PlainExtension;
 
 /**
  * @public
  */
-export declare function defineItalic(): Extension<    {
-Nodes: never;
-Marks: SimplifyDeeper<    {
-italic: Attrs;
-}>;
-Commands: {
-toggleItalic: [];
-};
-}>;
+export declare function defineItalic(): ItalicExtension;
 
-export declare function defineItalicCommands(): Extension<    {
-Commands: {
-toggleItalic: [];
-};
-Nodes: never;
-Marks: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineItalicCommands(): ItalicCommandsExtension;
 
-export declare function defineItalicInputRule(): Extension<ExtensionTyping<any, any, any>>;
+/**
+ * @internal
+ */
+export declare function defineItalicInputRule(): PlainExtension;
 
-export declare function defineItalicKeymap(): Extension<ExtensionTyping<any, any, any>>;
+/**
+ * @internal
+ */
+export declare function defineItalicKeymap(): PlainExtension;
 
-export declare function defineItalicSpec(): Extension<    {
-Marks: {
-italic: Attrs;
-};
-Nodes: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineItalicSpec(): ItalicSpecExtension;
 
 /**
  * @public
  */
-export declare function defineLink(): Extension<    {
-Nodes: never;
-Marks: SimplifyDeeper<    {
-link: LinkAttrs;
-}>;
-Commands: {
-addLink: [attrs: LinkAttrs];
-removeLink: [];
-toggleLink: [attrs: LinkAttrs];
-expandLink: [];
-};
-}>;
+export declare function defineLink(): LinkExtension;
 
-export declare function defineLinkCommands(): Extension<    {
-Commands: {
-addLink: [attrs: LinkAttrs];
-removeLink: [];
-toggleLink: [attrs: LinkAttrs];
-expandLink: [];
-};
-Nodes: never;
-Marks: never;
-}>;
+export declare function defineLinkCommands(): LinkCommandsExtension;
 
 /**
  * Apply link marks after typing Enter.
+ *
+ * @internal
  */
-export declare function defineLinkEnterRule(): Extension<ExtensionTyping<any, any, any>>;
+export declare function defineLinkEnterRule(): PlainExtension;
 
 /**
  * Apply link marks after pressing Space.
+ *
+ * @internal
  */
-export declare function defineLinkInputRule(): Extension<ExtensionTyping<any, any, any>>;
+export declare function defineLinkInputRule(): PlainExtension;
 
 /**
  * Apply and remove link marks to the text during typing.
+ *
+ * @internal
  */
 export declare function defineLinkMarkRule(): Extension<ExtensionTyping<any, any, any>>;
 
-export declare function defineLinkSpec(): Extension<    {
-Marks: {
-link: LinkAttrs;
-};
-Nodes: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineLinkSpec(): LinkSpecExtension;
 
 /**
  * @public
  */
-export declare function defineList(): Extension<    {
-Nodes: SimplifyDeeper<    {
-list: ListAttrs;
-}>;
-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(): ListExtension;
 
 /**
  * Defines list commands.
  *
  * @internal
  */
-declare function defineListCommands(): 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;
-}>;
+declare function defineListCommands(): ListCommandsExtension;
 export { defineListCommands }
 export { defineListCommands as defineListCommands_alias_1 }
 
@@ -670,27 +627,21 @@ export { defineListInputRules as defineListInputRules_alias_1 }
  *
  * @internal
  */
-declare function defineListKeymap(): Extension<ExtensionTyping<any, any, any>>;
+declare function defineListKeymap(): PlainExtension;
 export { defineListKeymap }
 export { defineListKeymap as defineListKeymap_alias_1 }
 
 /**
  * @internal
  */
-declare function defineListPlugins(): Extension<ExtensionTyping<any, any, any>>;
+declare function defineListPlugins(): PlainExtension;
 export { defineListPlugins }
 export { defineListPlugins as defineListPlugins_alias_1 }
 
 /**
  * @internal
  */
-declare function defineListSpec(): Extension<    {
-Nodes: {
-list: ListAttrs;
-};
-Marks: never;
-Commands: never;
-}>;
+declare function defineListSpec(): ListSpecExtension;
 export { defineListSpec }
 export { defineListSpec as defineListSpec_alias_1 }
 
@@ -700,7 +651,7 @@ export { defineListSpec as defineListSpec_alias_1 }
  *
  * @public
  */
-export declare function defineMarkInputRule(options: MarkInputRuleOptions): Extension;
+export declare function defineMarkInputRule(options: MarkInputRuleOptions): PlainExtension;
 
 /**
  * A mark rule is something that can automatically apply marks to text if it
@@ -713,22 +664,20 @@ export { defineMarkRule as defineMarkRule_alias_1 }
 /**
  * @public
  */
-export declare function defineMention(): Extension<    {
-Nodes: SimplifyDeeper<    {
+export declare function defineMention(): Union<readonly [Extension<    {
+Nodes: {
 mention: MentionAttrs;
-}>;
-Marks: never;
+};
+}>, Extension<    {
 Commands: {
 insertMention: [attrs: MentionAttrs];
 };
-}>;
+}>]>;
 
 export declare function defineMentionCommands(): Extension<    {
 Commands: {
 insertMention: [attrs: MentionAttrs];
 };
-Nodes: never;
-Marks: never;
 }>;
 
 /**
@@ -738,8 +687,6 @@ export declare function defineMentionSpec(): Extension<    {
 Nodes: {
 mention: MentionAttrs;
 };
-Marks: never;
-Commands: never;
 }>;
 
 /**
@@ -748,18 +695,18 @@ Commands: never;
  *
  * @public
  */
-export declare function defineModClickPrevention(): Extension;
+export declare function defineModClickPrevention(): ModClickPreventionExtension;
 
 /**
  * Add a placeholder text to the editor when the current block or document is
  * empty.
  */
-export declare function definePlaceholder(options: PlaceholderOptions): Extension<ExtensionTyping<any, any, any>>;
+export declare function definePlaceholder(options: PlaceholderOptions): PlainExtension;
 
 /**
  * Make the editor read-only.
  */
-export declare function defineReadonly(): Extension<ExtensionTyping<any, any, any>>;
+export declare function defineReadonly(): PlainExtension;
 
 /**
  * Defines commands for search and replace.
@@ -777,8 +724,6 @@ replaceNextNoWrap: [];
 replaceCurrent: [];
 replaceAll: [];
 };
-Nodes: never;
-Marks: never;
 }>;
 
 /**
@@ -786,75 +731,42 @@ Marks: never;
  *
  * @public
  */
-export declare function defineSearchQuery(options: SearchQueryOptions): Extension<ExtensionTyping<any, any, any>>;
+export declare function defineSearchQuery(options: SearchQueryOptions): PlainExtension;
 
 /**
  * @public
  */
-export declare function defineStrike(): Extension<    {
-Nodes: never;
-Marks: SimplifyDeeper<    {
-strike: Attrs;
-}>;
-Commands: {
-toggleStrike: [];
-};
-}>;
+export declare function defineStrike(): StrikeExtension;
 
-export declare function defineStrikeCommands(): Extension<    {
-Commands: {
-toggleStrike: [];
-};
-Nodes: never;
-Marks: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineStrikeCommands(): StrikeCommandsExtension;
 
-export declare function defineStrikeInputRule(): Extension<ExtensionTyping<any, any, any>>;
+/**
+ * @internal
+ */
+export declare function defineStrikeInputRule(): PlainExtension;
 
-export declare function defineStrikeKeymap(): Extension<ExtensionTyping<any, any, any>>;
+/**
+ * @internal
+ */
+export declare function defineStrikeKeymap(): PlainExtension;
 
-export declare function defineStrikeSpec(): Extension<    {
-Marks: {
-strike: Attrs;
-};
-Nodes: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineStrikeSpec(): StrikeSpecExtension;
 
 /**
  * @public
  */
-export declare function defineTable(): Extension<    {
-Nodes: SimplifyDeeper<    {
-table: Attrs;
-tableRow: Attrs;
-tableCell: {
-[x: string]: any;
-};
-tableHeaderCell: {
-[x: string]: any;
-};
-}>;
-Marks: never;
-Commands: {
-insertTable: [{
-row: number;
-col: number;
-header: boolean;
-}];
-exitTable: [];
-};
-}>;
+export declare function defineTable(): TableExtension;
 
-declare function defineTableCellSpec(): Extension<    {
-Nodes: {
-tableCell: {
-[x: string]: any;
-};
-};
-Marks: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+declare function defineTableCellSpec(): TableCellSpecExtension;
 export { defineTableCellSpec }
 export { defineTableCellSpec as defineTableCellSpec_alias_1 }
 
@@ -863,164 +775,43 @@ export { defineTableCellSpec as defineTableCellSpec_alias_1 }
  *
  * @public
  */
-declare function defineTableCommands(): Extension<    {
-Commands: {
-insertTable: [{
-row: number;
-col: number;
-header: boolean;
-}];
-exitTable: [];
-};
-Nodes: never;
-Marks: never;
-}>;
+declare function defineTableCommands(): TableCommandsExtension;
 export { defineTableCommands }
 export { defineTableCommands as defineTableCommands_alias_1 }
 
-declare function defineTableHeaderCellSpec(): Extension<    {
-Nodes: {
-tableHeaderCell: {
-[x: string]: any;
-};
-};
-Marks: never;
-Commands: never;
-}>;
+declare function defineTableHeaderCellSpec(): TableHeaderCellSpecExtension;
 export { defineTableHeaderCellSpec }
 export { defineTableHeaderCellSpec as defineTableHeaderCellSpec_alias_1 }
 
 /**
  * @public
  */
-declare function defineTablePlugins(): Extension<ExtensionTyping<any, any, any>>;
+declare function defineTablePlugins(): PlainExtension;
 export { defineTablePlugins }
 export { defineTablePlugins as defineTablePlugins_alias_1 }
 
-declare function defineTableRowSpec(): Extension<    {
-Nodes: {
-tableRow: Attrs_2;
-};
-Marks: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+declare function defineTableRowSpec(): TableRowSpecExtension;
 export { defineTableRowSpec }
 export { defineTableRowSpec as defineTableRowSpec_alias_1 }
 
-declare function defineTableSpec(): Extension<    {
-Nodes: {
-table: Attrs_2;
-};
-Marks: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+declare function defineTableSpec(): TableSpecExtension;
 export { defineTableSpec }
 export { defineTableSpec as defineTableSpec_alias_1 }
 
 /**
  * @internal
  */
-export declare function defineTestExtension(): Extension<{
-    Nodes: SimplifyDeeper<    {
-    paragraph: Attrs;
-    doc: Attrs;
-    text: Attrs;
-    blockquote: {
-    readonly [x: string]: any;
-    };
-    heading: {
-    level: number;
-    };
-    image: {
-    src: null;
-    };
-    list: {
-    kind?: "bullet" | "ordered" | "task" | "toggle";
-    order?: number | null;
-    checked?: boolean;
-    collapsed?: boolean;
-    };
-    table: {
-    readonly [x: string]: any;
-    };
-    tableRow: {
-    readonly [x: string]: any;
-    };
-    tableCell: {
-    [x: string]: any;
-    };
-    tableHeaderCell: {
-    [x: string]: any;
-    };
-    }>;
-    Marks: SimplifyDeeper<    {
-    bold: {
-    readonly [x: string]: any;
-    };
-    code: {
-    readonly [x: string]: any;
-    };
-    italic: {
-    readonly [x: string]: any;
-    };
-    link: {
-    href: string;
-    };
-    strike: {
-    readonly [x: string]: any;
-    };
-    underline: {
-    readonly [x: string]: any;
-    };
-    }>;
-    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(): Union<readonly [DocExtension, TextExtension, HeadingExtension, HistoryExtension, ListExtension, BlockquoteExtension, PlainExtension, BaseCommandsExtension, ItalicExtension, BoldExtension, UnderlineExtension, StrikeExtension, CodeExtension, LinkExtension, ImageExtension, Extension<{
+Nodes: {
+paragraph: Attrs_2;
+};
+}>, TableExtension]>;
 
 /**
  * Adds a `textAlign` attribute to the specified nodes. This will be rendered as
@@ -1028,29 +819,17 @@ export declare function defineTestExtension(): Extension<{
  *
  * @public
  */
-export declare function defineTextAlign<NodeName extends string = string>(options: TextAlignOptions<NodeName>): Extension<{
-    Nodes: {
-        [K in NodeName]: {
-            textAlign: string | null;
-        };
-    };
-    Marks: never;
-    Commands: TextAlignCommandTyping;
-}>;
+export declare function defineTextAlign<NodeName extends string = string>(options: TextAlignOptions<NodeName>): TextAlignExtension<NodeName>;
 
 /**
  * @internal
  */
-export declare function defineTextAlignCommands(types: string[]): Extension<{
-    Nodes: never;
-    Marks: never;
-    Commands: TextAlignCommandTyping;
-}>;
+export declare function defineTextAlignCommands(types: string[]): TextAlignCommandsExtension;
 
 /**
  * @internal
  */
-export declare function defineTextAlignKeymap(types: string[]): Extension<ExtensionTyping<any, any, any>>;
+export declare function defineTextAlignKeymap(types: string[]): PlainExtension;
 
 /**
  * Defines an enter rule that replaces the matched text with a block node.
@@ -1059,7 +838,7 @@ export declare function defineTextAlignKeymap(types: string[]): Extension<Extens
  *
  * @public
  */
-export declare function defineTextBlockEnterRule({ regex, type, attrs, stop, }: TextBlockEnterRuleOptions): Extension;
+export declare function defineTextBlockEnterRule(options: TextBlockEnterRuleOptions): PlainExtension;
 
 /**
  * Defines an input rule that changes the type of a textblock when the matched
@@ -1083,39 +862,28 @@ export declare function defineTextBlockInputRule({ regex, type, attrs, }: {
     /**
      * Attributes to set on the node.
      */
-    attrs?: Attrs_2 | null | ((match: RegExpMatchArray) => Attrs_2 | null);
-}): Extension;
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+}): PlainExtension;
 
 /**
  * @public
  */
-export declare function defineUnderline(): Extension<    {
-Nodes: never;
-Marks: SimplifyDeeper<    {
-underline: Attrs;
-}>;
-Commands: {
-toggleUnderline: [];
-};
-}>;
+export declare function defineUnderline(): UnderlineExtension;
 
-export declare function defineUnderlineCommands(): Extension<    {
-Commands: {
-toggleUnderline: [];
-};
-Nodes: never;
-Marks: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineUnderlineCommands(): UnderlineCommandsExtension;
 
-export declare function defineUnderlineKeymap(): Extension<ExtensionTyping<any, any, any>>;
+/**
+ * @internal
+ */
+export declare function defineUnderlineKeymap(): PlainExtension;
 
-export declare function defineUnderlineSpec(): Extension<    {
-Marks: {
-underline: Attrs;
-};
-Nodes: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineUnderlineSpec(): UnderlineSpecExtension;
 
 /**
  * Shows a virtual selection when the editor is not focused. When the editor is
@@ -1127,7 +895,7 @@ Commands: never;
  *
  * @public
  */
-export declare function defineVirtualSelection(): Extension;
+export declare function defineVirtualSelection(): VirtualSelectionExtension;
 
 /**
  * Defines an input rule for automatically wrapping a textblock when a given
@@ -1151,7 +919,7 @@ export declare function defineWrappingInputRule({ regex, type, attrs, join, }: {
     /**
      * Attributes to set on the node.
      */
-    attrs?: Attrs_2 | null | ((match: RegExpMatchArray) => Attrs_2 | null);
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
     /**
      * By default, if there's a node with the same type above the newly wrapped
      * node, the rule will try to
@@ -1161,7 +929,12 @@ export declare function defineWrappingInputRule({ regex, type, attrs, join, }: {
      * indicate whether a join should happen.
      */
     join?: (match: RegExpMatchArray, node: ProseMirrorNode) => boolean;
-}): Extension;
+}): PlainExtension;
+
+/**
+ * @internal
+ */
+export declare type DropCursorExtension = PlainExtension;
 
 export declare interface DropCursorOptions {
     /**
@@ -1234,6 +1007,13 @@ export declare type EnterRuleOptions = {
  */
 export declare const exitTable: Command;
 
+export { GapCursor }
+
+/**
+ * @internal
+ */
+export declare type GapCursorExtension = PlainExtension;
+
 export declare function getCheckRanges(transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Array<[number, number]>;
 
 export declare function getPluginState(state: EditorState): PredictionPluginState | undefined;
@@ -1248,6 +1028,38 @@ declare interface HeadingAttrs {
 export { HeadingAttrs }
 export { HeadingAttrs as HeadingAttrs_alias_1 }
 
+/**
+ * @internal
+ */
+declare type HeadingCommandsExtension = Extension<{
+    Commands: {
+        setHeading: [attrs?: HeadingAttrs | undefined];
+        insertHeading: [attrs?: HeadingAttrs | undefined];
+        toggleHeading: [attrs?: HeadingAttrs | undefined];
+    };
+}>;
+export { HeadingCommandsExtension }
+export { HeadingCommandsExtension as HeadingCommandsExtension_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type HeadingExtension = Union<[
+HeadingSpecExtension,
+HeadingCommandsExtension
+]>;
+
+/**
+ * @internal
+ */
+declare type HeadingSpecExtension = Extension<{
+    Nodes: {
+        heading: HeadingAttrs;
+    };
+}>;
+export { HeadingSpecExtension }
+export { HeadingSpecExtension as HeadingSpecExtension_alias_1 }
+
 export declare type HighlighterOptions = {
     themes: BundledTheme[];
     langs: (BundledLanguage | SpecialLanguage)[];
@@ -1271,10 +1083,36 @@ declare type HighlightParser = Parser;
 export { HighlightParser }
 export { HighlightParser as HighlightParser_alias_1 }
 
+/**
+ * @public
+ */
 export declare interface ImageAttrs {
     src?: string | null;
 }
 
+/**
+ * @internal
+ */
+export declare type ImageCommandsExtension = Extension<{
+    Commands: {
+        insertImage: [attrs?: ImageAttrs];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type ImageExtension = Union<[ImageSpecExtension, ImageCommandsExtension]>;
+
+/**
+ * @internal
+ */
+export declare type ImageSpecExtension = Extension<{
+    Nodes: {
+        image: ImageAttrs;
+    };
+}>;
+
 export { IndentListOptions }
 
 /**
@@ -1283,11 +1121,42 @@ export { IndentListOptions }
  *
  * @public
  */
-export declare function insertTable({ row, col, header, }: {
+export declare function insertTable({ row, col, header }: InsertTableOptions): Command;
+
+/**
+ * @public
+ */
+export declare interface InsertTableOptions {
     row: number;
     col: number;
     header: boolean;
-}): Command;
+}
+
+/**
+ * @internal
+ */
+export declare type ItalicCommandsExtension = Extension<{
+    Commands: {
+        toggleItalic: [];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type ItalicExtension = Union<[
+ItalicSpecExtension,
+ItalicCommandsExtension
+]>;
+
+/**
+ * @internal
+ */
+export declare type ItalicSpecExtension = Extension<{
+    Marks: {
+        italic: Attrs;
+    };
+}>;
 
 export declare const LINK_ENTER_RE: RegExp;
 
@@ -1302,6 +1171,32 @@ export declare interface LinkAttrs {
     href: string;
 }
 
+/**
+ * @internal
+ */
+export declare type LinkCommandsExtension = Extension<{
+    Commands: {
+        addLink: [LinkAttrs];
+        removeLink: [];
+        toggleLink: [LinkAttrs];
+        expandLink: [];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type LinkExtension = Union<[LinkSpecExtension, LinkCommandsExtension]>;
+
+/**
+ * @internal
+ */
+export declare type LinkSpecExtension = Extension<{
+    Marks: {
+        link: LinkAttrs;
+    };
+}>;
+
 /**
  * The attributes of a list node.
  *
@@ -1328,8 +1223,43 @@ declare interface ListAttrs {
 export { ListAttrs }
 export { ListAttrs as ListAttrs_alias_1 }
 
+/**
+ * @internal
+ */
+declare type ListCommandsExtension = Extension<{
+    Commands: {
+        dedentList: [options?: DedentListOptions];
+        indentList: [options?: IndentListOptions];
+        moveList: [direction: 'up' | 'down'];
+        splitList: [];
+        toggleCollapsed: [options?: ToggleCollapsedOptions];
+        unwrapList: [options?: UnwrapListOptions];
+        toggleList: [attrs?: ListAttributes];
+        wrapInList: [attrs?: ListAttributes];
+        insertList: [attrs?: ListAttributes];
+    };
+}>;
+export { ListCommandsExtension }
+export { ListCommandsExtension as ListCommandsExtension_alias_1 }
+
 export { ListDOMSerializer }
 
+/**
+ * @internal
+ */
+export declare type ListExtension = Union<[ListSpecExtension, ListCommandsExtension]>;
+
+/**
+ * @internal
+ */
+declare type ListSpecExtension = Extension<{
+    Nodes: {
+        list: ListAttrs;
+    };
+}>;
+export { ListSpecExtension }
+export { ListSpecExtension as ListSpecExtension_alias_1 }
+
 /**
  * Options for {@link defineMarkInputRule}.
  *
@@ -1349,7 +1279,7 @@ export declare interface MarkInputRuleOptions {
     /**
      * Attributes to set on the mark.
      */
-    attrs?: Attrs_2 | null | ((match: RegExpMatchArray) => Attrs_2 | null);
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
 }
 
 /**
@@ -1373,7 +1303,7 @@ declare interface MarkRuleOptions {
      *
      * @default null
      */
-    attrs?: Attrs_2 | null | ((match: RegExpMatchArray) => Attrs_2 | null);
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
 }
 export { MarkRuleOptions }
 export { MarkRuleOptions as MarkRuleOptions_alias_1 }
@@ -1395,6 +1325,11 @@ export declare interface MentionAttrs {
     kind: string;
 }
 
+/**
+ * @internal
+ */
+export declare type ModClickPreventionExtension = PlainExtension;
+
 export declare interface PlaceholderOptions {
     /**
      * The placeholder text to use.
@@ -1493,107 +1428,11 @@ export declare function setTrMeta(tr: Transaction, meta: PredictionPluginState):
  * @internal
  */
 export declare function setupTest(): {
-    editor: TestEditor<Extension<{
-        Nodes: SimplifyDeeper<    {
-        paragraph: Attrs;
-        doc: Attrs;
-        text: Attrs;
-        blockquote: {
-        readonly [x: string]: any;
-        };
-        heading: {
-        level: number;
-        };
-        image: {
-        src: null;
-        };
-        list: {
-        kind?: "bullet" | "ordered" | "task" | "toggle";
-        order?: number | null;
-        checked?: boolean;
-        collapsed?: boolean;
-        };
-        table: {
-        readonly [x: string]: any;
-        };
-        tableRow: {
-        readonly [x: string]: any;
-        };
-        tableCell: {
-        [x: string]: any;
-        };
-        tableHeaderCell: {
-        [x: string]: any;
-        };
-        }>;
-        Marks: SimplifyDeeper<    {
-        bold: {
-        readonly [x: string]: any;
-        };
-        code: {
-        readonly [x: string]: any;
-        };
-        italic: {
-        readonly [x: string]: any;
-        };
-        link: {
-        href: string;
-        };
-        strike: {
-        readonly [x: string]: any;
-        };
-        underline: {
-        readonly [x: string]: any;
-        };
-        }>;
-        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<Union<readonly [DocExtension, TextExtension, HeadingExtension, HistoryExtension, ListExtension, BlockquoteExtension, PlainExtension, BaseCommandsExtension, ItalicExtension, BoldExtension, UnderlineExtension, StrikeExtension, CodeExtension, LinkExtension, ImageExtension, Extension<{
+    Nodes: {
+    paragraph: Attrs_2;
+    };
+    }>, TableExtension]>>;
     m: ToMarkAction<SimplifyDeeper<    {
     bold: {
     readonly [x: string]: any;
@@ -1630,10 +1469,10 @@ export declare function setupTest(): {
         unchecked: (...children: NodeChild[]) => Node_2;
         collapsed: (...children: NodeChild[]) => Node_2;
         expanded: (...children: NodeChild[]) => Node_2;
-        paragraph: NodeAction<    {
+        doc: NodeAction<    {
         readonly [x: string]: any;
         }>;
-        doc: NodeAction<    {
+        paragraph: NodeAction<    {
         readonly [x: string]: any;
         }>;
         text: NodeAction<    {
@@ -1646,7 +1485,7 @@ export declare function setupTest(): {
         level: number;
         }>;
         image: NodeAction<    {
-        src: null;
+        src?: string | null;
         }>;
         list: NodeAction<    {
         kind?: "bullet" | "ordered" | "task" | "toggle";
@@ -1661,10 +1500,14 @@ export declare function setupTest(): {
         readonly [x: string]: any;
         }>;
         tableCell: NodeAction<    {
-        [x: string]: any;
+        colspan: number;
+        rowspan: number;
+        colwidth: number[] | null;
         }>;
         tableHeaderCell: NodeAction<    {
-        [x: string]: any;
+        colspan: number;
+        rowspan: number;
+        colwidth: number[] | null;
         }>;
     };
 };
@@ -1681,10 +1524,127 @@ export declare function setupTestFromExtension<E extends Extension>(extension: E
 /**
  * @internal
  */
-export declare type TextAlignCommandTyping = {
-    setTextAlign: [value: string | null];
-};
+export declare type StrikeCommandsExtension = Extension<{
+    Commands: {
+        toggleStrike: [];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type StrikeExtension = Union<[
+StrikeSpecExtension,
+StrikeCommandsExtension
+]>;
+
+/**
+ * @internal
+ */
+export declare type StrikeSpecExtension = Extension<{
+    Marks: {
+        strike: Attrs;
+    };
+}>;
+
+/**
+ * @internal
+ */
+declare type TableCellSpecExtension = Extension<{
+    Nodes: {
+        tableCell: CellAttrs;
+    };
+}>;
+export { TableCellSpecExtension }
+export { TableCellSpecExtension as TableCellSpecExtension_alias_1 }
+
+/**
+ * @internal
+ */
+declare type TableCommandsExtension = Extension<{
+    Commands: {
+        insertTable: [InsertTableOptions];
+        exitTable: [];
+    };
+}>;
+export { TableCommandsExtension }
+export { TableCommandsExtension as TableCommandsExtension_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type TableExtension = Union<[
+TableSpecExtension,
+TableRowSpecExtension,
+TableCellSpecExtension,
+TableHeaderCellSpecExtension,
+TableCommandsExtension
+]>;
+
+/**
+ * @internal
+ */
+declare type TableHeaderCellSpecExtension = Extension<{
+    Nodes: {
+        tableHeaderCell: CellAttrs;
+    };
+}>;
+export { TableHeaderCellSpecExtension }
+export { TableHeaderCellSpecExtension as TableHeaderCellSpecExtension_alias_1 }
+
+/**
+ * @internal
+ */
+declare type TableRowSpecExtension = Extension<{
+    Nodes: {
+        tableRow: Attrs;
+    };
+}>;
+export { TableRowSpecExtension }
+export { TableRowSpecExtension as TableRowSpecExtension_alias_1 }
+
+/**
+ * @internal
+ */
+declare type TableSpecExtension = Extension<{
+    Nodes: {
+        table: Attrs;
+    };
+}>;
+export { TableSpecExtension }
+export { TableSpecExtension as TableSpecExtension_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type TextAlignAttrsExtension<NodeName extends string> = Extension<{
+    Nodes: {
+        [K in NodeName]: {
+            textAlign: string | null;
+        };
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type TextAlignCommandsExtension = Extension<{
+    Commands: {
+        setTextAlign: [value: string | null];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type TextAlignExtension<NodeName extends string> = Union<[
+TextAlignAttrsExtension<NodeName>,
+TextAlignCommandsExtension
+]>;
 
+/**
+ * @public
+ */
 export declare interface TextAlignOptions<NodeName extends string = string> {
     /**
      * The names of node to add the attribute to.
@@ -1720,7 +1680,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_2 | null | ((match: RegExpMatchArray) => Attrs_2 | null);
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
     /**
      * Whether to stop further handlers from being called if this rule is triggered.
      *
@@ -1731,8 +1691,39 @@ export declare type TextBlockEnterRuleOptions = {
 
 export { ToggleCollapsedOptions }
 
+/**
+ * @internal
+ */
+export declare type UnderlineCommandsExtension = Extension<{
+    Commands: {
+        toggleUnderline: [];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type UnderlineExtension = Union<[
+UnderlineSpecExtension,
+UnderlineCommandsExtension
+]>;
+
+/**
+ * @internal
+ */
+export declare type UnderlineSpecExtension = Extension<{
+    Marks: {
+        underline: Attrs;
+    };
+}>;
+
 export { UnwrapListOptions }
 
+/**
+ * @internal
+ */
+export declare type VirtualSelectionExtension = PlainExtension;
+
 export { WrapInListGetAttrs }
 
 export { }