@prosekit/core 0.7.2 → 0.7.4

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

@@ -1,5 +1,6 @@
 import { AllSelection } from '@prosekit/pm/state';
 import { Attrs } from '@prosekit/pm/model';
+import { Attrs as Attrs_2 } from 'prosemirror-model';
 import { Command } from '@prosekit/pm/state';
 import type { ContentMatch } from '@prosekit/pm/model';
 import { config as default_alias_1 } from '@prosekit/dev/config-vitest';
@@ -19,8 +20,8 @@ import { NodeSelection } from '@prosekit/pm/state';
 import type { NodeSpec } from '@prosekit/pm/model';
 import { NodeType } from '@prosekit/pm/model';
 import { NodeType as NodeType_2 } from 'prosemirror-model';
-import { NodeView } from '@prosekit/pm/view';
-import { NodeViewConstructor } from '@prosekit/pm/view';
+import type { NodeView } from '@prosekit/pm/view';
+import type { NodeViewConstructor } from '@prosekit/pm/view';
 import { Options } from 'tsup';
 import type { ParseOptions } from '@prosekit/pm/model';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
@@ -75,6 +76,15 @@ declare interface AddMarkOptions {
 export { AddMarkOptions }
 export { AddMarkOptions as AddMarkOptions_alias_1 }
 
+/**
+ * An object holding the attributes of a node.
+
+ * @public
+ */
+declare type AnyAttrs = Attrs;
+export { AnyAttrs }
+export { AnyAttrs as AnyAttrs_alias_1 }
+
 export declare function applyAction(operator: Action): Command;
 
 export declare const applyMarkForTest: ApplyMarkFunction;
@@ -106,8 +116,38 @@ export { assert as assert_alias_1 }
  */
 export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
 
+/**
+ * Utility function assert that two types are equal in tests.
+ */
+export declare function assertTypeEqual_alias_1<T, U>(_val: IsEqual<T, U>): void;
+
 export declare function attrsMatch(nodeOrMark: ProseMirrorNode | Mark, attrs: Attrs): boolean;
 
+/**
+ * @public
+ */
+declare type AttrSpec<AttrType = any> = {
+    /**
+     * The default value for this attribute, to use when no explicit value is
+     * provided. Attributes that have no default must be provided whenever a node
+     * or mark of a type that has them is created.
+     */
+    default?: AttrType;
+    /**
+     * A function or type name used to validate values of this attribute. This
+     * will be used when deserializing the attribute from JSON, and when running
+     * [`Node.check`](https://prosemirror.net/docs/ref/#model.Node.check). When a
+     * function, it should raise an exception if the value isn't of the expected
+     * type or shape. When a string, it should be a `|`-separated string of
+     * primitive types (`"number"`, `"string"`, `"boolean"`, `"null"`, and
+     * `"undefined"`), and the library will raise an error when the value is not
+     * one of those types.
+     */
+    validate?: string | ((value: unknown) => void);
+};
+export { AttrSpec }
+export { AttrSpec as AttrSpec_alias_1 }
+
 /**
  * @internal
  */
@@ -199,10 +239,19 @@ export { collectNodes as collectNodes_alias_1 }
 
 export declare function combineEventHandlers<Handler extends (...args: any[]) => boolean | void, Args extends Parameters<Handler> = Parameters<Handler>>(): readonly [(handlers: Handler[]) => void, (...args: Args) => boolean];
 
-export declare interface CommandApplier<Args extends any[] = any[]> {
+/**
+ * A function to apply a command to the editor. It will return `true` if the command was applied, and `false` otherwise.
+ *
+ * It also has a `canApply` method to check if the command can be applied.
+ *
+ * @public
+ */
+declare interface CommandAction<Args extends any[] = any[]> {
     (...args: Args): boolean;
     canApply(...args: Args): boolean;
 }
+export { CommandAction }
+export { CommandAction as CommandAction_alias_1 }
 
 export declare type CommandCreator<Args extends any[] = any[]> = (...arg: Args) => Command;
 
@@ -233,12 +282,12 @@ export { createEditor as createEditor_alias_1 }
 /**
  * @internal
  */
-export declare function createMarkBuilders(schema: Schema, getState: () => EditorState | null | undefined, applyMark?: ApplyMarkFunction): Record<string, MarkBuilder>;
+export declare function createMarkActions(schema: Schema, getState: () => EditorState | null | undefined, applyMark?: ApplyMarkFunction): Record<string, MarkAction>;
 
 /**
  * @internal
  */
-export declare function createNodeBuilders(schema: Schema, getState: () => EditorState | null | undefined, createNode?: CreateNodeFunction): Record<string, NodeBuilder>;
+export declare function createNodeActions(schema: Schema, getState: () => EditorState | null | undefined, createNode?: CreateNodeFunction): Record<string, NodeAction>;
 
 export declare const createNodeForTest: CreateNodeFunction;
 
@@ -368,7 +417,9 @@ export { defineDefaultState as defineDefaultState_alias_1 }
  * @public
  */
 declare function defineDoc(): Extension<    {
-Nodes: "doc";
+Nodes: {
+doc: Attrs_2;
+};
 Marks: never;
 Commands: never;
 }>;
@@ -465,13 +516,15 @@ export { defineFocusChangeHandler as defineFocusChangeHandler_alias_1 }
 
 /**
  * Add undo/redo history to the editor.
+ *
+ * @public
  */
-declare function defineHistory(): Extension<    {
+declare function defineHistory({ depth, newGroupDelay, }?: HistoryOptions): Extension<    {
 Nodes: never;
 Marks: never;
 Commands: {
-undo: [];
-redo: [];
+readonly undo: [];
+readonly redo: [];
 };
 }>;
 export { defineHistory }
@@ -505,15 +558,23 @@ export { defineKeyPressHandler as defineKeyPressHandler_alias_1 }
 /**
  * @public
  */
-declare function defineMarkAttr(options: MarkAttrOptions): Extension;
+declare function defineMarkAttr<MarkType extends string = string, AttrName extends string = string, AttrType = any>(options: MarkAttrOptions<MarkType, AttrName, AttrType>): Extension<{
+    Nodes: never;
+    Marks: {
+        [K in MarkType]: AttrType;
+    };
+    Commands: never;
+}>;
 export { defineMarkAttr }
 export { defineMarkAttr as defineMarkAttr_alias_1 }
 
 /**
  * @public
  */
-declare function defineMarkSpec<Mark extends string>(options: MarkSpecOptions<Mark>): Extension<{
-    Marks: Mark;
+declare function defineMarkSpec<Mark extends string, Attrs extends AnyAttrs = AnyAttrs>(options: MarkSpecOptions<Mark, Attrs>): Extension<{
+    Marks: {
+        [K in Mark]: Attrs;
+    };
     Nodes: never;
     Commands: never;
 }>;
@@ -534,7 +595,15 @@ export { defineMountHandler as defineMountHandler_alias_1 }
  *
  * @public
  */
-declare function defineNodeAttr(options: NodeAttrOptions): Extension;
+declare function defineNodeAttr<NodeType extends string = string, AttrName extends string = string, AttrType = any>(options: NodeAttrOptions<NodeType, AttrName, AttrType>): Extension<{
+    Nodes: {
+        [K in NodeType]: {
+            [K in AttrName]: AttrType;
+        };
+    };
+    Marks: never;
+    Commands: never;
+}>;
 export { defineNodeAttr }
 export { defineNodeAttr as defineNodeAttr_alias_1 }
 
@@ -543,8 +612,10 @@ export { defineNodeAttr as defineNodeAttr_alias_1 }
  *
  * @public
  */
-declare function defineNodeSpec<Node extends string>(options: NodeSpecOptions<Node>): Extension<{
-    Nodes: Node;
+declare function defineNodeSpec<Node extends string, Attrs extends AnyAttrs = AnyAttrs>(options: NodeSpecOptions<Node, Attrs>): Extension<{
+    Nodes: {
+        [K in Node]: Attrs;
+    };
     Marks: never;
     Commands: never;
 }>;
@@ -575,7 +646,9 @@ export { defineNodeViewFactory as defineNodeViewFactory_alias_1 }
  * Defines a paragraph node spec as the highest priority, because it should be the default block node for most cases.
  */
 declare function defineParagraph(): Extension<    {
-Nodes: "paragraph";
+Nodes: {
+paragraph: Attrs_2;
+};
 Marks: never;
 Commands: never;
 }>;
@@ -588,7 +661,9 @@ export { defineParagraph as defineParagraph_alias_1 }
  * Defines a paragraph node spec.
  */
 export declare function defineParagraphSpec(): Extension<    {
-Nodes: "paragraph";
+Nodes: {
+paragraph: Attrs_2;
+};
 Marks: never;
 Commands: never;
 }>;
@@ -629,8 +704,16 @@ export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_
  * @internal
  */
 export declare function defineTestExtension(): Extension<{
-    Nodes: "text" | "doc" | "paragraph" | "heading";
-    Marks: "bold" | "italic";
+    Nodes: SimplifyDeeper<    {
+    paragraph: Attrs_2;
+    doc: Attrs_2;
+    text: Attrs_2;
+    heading: Attrs_2;
+    }>;
+    Marks: SimplifyDeeper<    {
+    bold: Attrs_2;
+    italic: Attrs_2;
+    }>;
     Commands: {
         insertText: [{
             text: string;
@@ -647,8 +730,8 @@ export declare function defineTestExtension(): Extension<{
         removeMark: [options: RemoveMarkOptions];
         unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
         unsetMark: [options?: UnsetMarkOptions | undefined];
-        undo: [];
-        redo: [];
+        readonly undo: [];
+        readonly redo: [];
     };
 }>;
 
@@ -656,7 +739,9 @@ export declare function defineTestExtension(): Extension<{
  * @public
  */
 declare function defineText(): Extension<    {
-Nodes: "text";
+Nodes: {
+text: Attrs_2;
+};
 Marks: never;
 Commands: never;
 }>;
@@ -809,11 +894,7 @@ declare class Editor<E extends Extension = any> {
     /**
      * The editor schema.
      */
-    get schema(): Schema<ExtractNodes<E>, ExtractMarks<E>>;
-    /**
-     * All commands defined by the editor.
-     */
-    get commands(): ExtractCommandAppliers<E>;
+    get schema(): Schema<ExtractNodeNames<E>, ExtractMarkNames<E>>;
     /**
      * Whether the editor is focused.
      */
@@ -853,8 +934,18 @@ declare class Editor<E extends Extension = any> {
      * directly manipulate the editor's state.
      */
     updateState(state: EditorState): void;
-    get nodes(): Record<ExtractNodes<E>, NodeBuilder>;
-    get marks(): Record<ExtractMarks<E>, MarkBuilder>;
+    /**
+     * All {@link CommandAction}s defined by the editor.
+     */
+    get commands(): ExtractCommandActions<E>;
+    /**
+     * All {@link NodeAction}s defined by the editor.
+     */
+    get nodes(): ExtractNodeActions<E>;
+    /**
+     * All {@link MarkAction}s defined by the editor.
+     */
+    get marks(): ExtractMarkActions<E>;
 }
 export { Editor }
 export { Editor as Editor_alias_1 }
@@ -865,9 +956,9 @@ export { Editor as Editor_alias_1 }
 export declare class EditorInstance {
     view: EditorView | null;
     schema: Schema;
-    nodeBuilders: Record<string, NodeBuilder>;
-    markBuilders: Record<string, MarkBuilder>;
-    commandAppliers: Record<string, CommandApplier>;
+    nodes: Record<string, NodeAction>;
+    marks: Record<string, MarkAction>;
+    commands: Record<string, CommandAction>;
     private tree;
     private directEditorProps;
     constructor(extension: Extension);
@@ -986,7 +1077,7 @@ export { Extension as Extension_alias_1 }
 /**
  * @internal
  */
-declare interface ExtensionTyping<N extends string | never = never, M extends string | never = never, C extends CommandTyping | never = never> {
+declare interface ExtensionTyping<N extends NodeTyping | never = never, M extends MarkTyping | never = never, C extends CommandTyping | never = never> {
     Nodes: N;
     Marks: M;
     Commands: C;
@@ -995,9 +1086,18 @@ export { ExtensionTyping }
 export { ExtensionTyping as ExtensionTyping_alias_1 }
 
 /**
+ * Extracts the {@link CommandAction}s from an extension type.
+ *
  * @public
  */
-declare type ExtractCommandAppliers<E extends Extension> = ToCommandApplier<ExtractCommands<E>>;
+declare type ExtractCommandActions<E extends Extension> = ToCommandAction<ExtractCommands<E>>;
+export { ExtractCommandActions }
+export { ExtractCommandActions as ExtractCommandActions_alias_1 }
+
+/**
+ * @deprecated Use `ExtractCommandActions` instead.
+ */
+declare type ExtractCommandAppliers<E extends Extension> = ExtractCommandActions<E>;
 export { ExtractCommandAppliers }
 export { ExtractCommandAppliers as ExtractCommandAppliers_alias_1 }
 
@@ -1013,17 +1113,45 @@ export { ExtractCommandCreators as ExtractCommandCreators_alias_1 }
  */
 export declare type ExtractCommands<E extends Extension> = SimplifyUnion<ExtractTyping<E>['Commands']>;
 
+/**
+ * Extracts the {@link MarkAction}s from an extension type.
+ *
+ * @public
+ */
+declare type ExtractMarkActions<E extends Extension> = ToMarkAction<ExtractMarks<E>>;
+export { ExtractMarkActions }
+export { ExtractMarkActions as ExtractMarkActions_alias_1 }
+
 /**
  * @public
  */
-declare type ExtractMarks<E extends Extension> = ExtractTyping<E>['Marks'];
+export declare type ExtractMarkNames<E extends Extension> = PickStringLiteral<keyof ExtractMarks<E>>;
+
+/**
+ * @public
+ */
+declare type ExtractMarks<E extends Extension> = SimplifyDeeper<SimplifyUnion<ExtractTyping<E>['Marks']>>;
 export { ExtractMarks }
 export { ExtractMarks as ExtractMarks_alias_1 }
 
+/**
+ * Extracts the {@link NodeAction}s from an extension type.
+ *
+ * @public
+ */
+declare type ExtractNodeActions<E extends Extension> = ToNodeAction<ExtractNodes<E>>;
+export { ExtractNodeActions }
+export { ExtractNodeActions as ExtractNodeActions_alias_1 }
+
+/**
+ * @public
+ */
+export declare type ExtractNodeNames<E extends Extension> = PickStringLiteral<keyof ExtractNodes<E>>;
+
 /**
  * @public
  */
-declare type ExtractNodes<E extends Extension> = ExtractTyping<E>['Nodes'];
+declare type ExtractNodes<E extends Extension> = SimplifyDeeper<SimplifyUnion<ExtractTyping<E>['Nodes']>>;
 export { ExtractNodes }
 export { ExtractNodes as ExtractNodes_alias_1 }
 
@@ -1032,7 +1160,7 @@ export declare function extractTags(node: TaggedProseMirrorNode): Record<string,
 /**
  * @internal
  */
-export declare type ExtractTyping<E extends Extension> = E extends Extension<ExtensionTyping<infer N, infer M, infer C>> ? ExtensionTyping<PickStringLiteral<N>, PickStringLiteral<M>, PickKnownCommandTyping<C>> : never;
+export declare type ExtractTyping<E extends Extension> = E extends Extension<ExtensionTyping<infer N, infer M, infer C>> ? ExtensionTyping<PickSubType<N, NodeTyping>, PickSubType<M, MarkTyping>, PickSubType<C, CommandTyping>> : never;
 
 /**
  * @internal
@@ -1171,6 +1299,30 @@ export declare type GroupedEntries<T extends Record<string, any>> = {
 
 export declare function groupEntries<T extends Record<string, any>>(entries: ObjectEntries<T>[]): GroupedEntries<T>;
 
+/**
+ * Options for {@link defineHistory}.
+ *
+ * @public
+ */
+declare interface HistoryOptions {
+    /**
+     * The amount of history events that are collected before the oldest events
+     * are discarded.
+     *
+     * @default 200
+     */
+    depth?: number;
+    /**
+     * The delay in milliseconds between changes after which a new group should be
+     * started.
+     *
+     * @default 250
+     */
+    newGroupDelay?: number;
+}
+export { HistoryOptions }
+export { HistoryOptions as HistoryOptions_alias_1 }
+
 /**
  * @internal
  */
@@ -1401,23 +1553,39 @@ export { KeyPressHandler }
 export { KeyPressHandler as KeyPressHandler_alias_1 }
 
 /**
+ * A function for creating a mark with optional attributes and any number of
+ * children.
+ *
+ * It also has a `isActive` method for checking if the mark is active in the
+ * current editor selection.
+ *
  * @public
  */
-declare interface MarkAttrOptions {
+declare interface MarkAction<Attrs extends AnyAttrs = AnyAttrs> {
+    (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode[];
+    (...children: NodeChild[]): ProseMirrorNode[];
     /**
-     * The name of the mark type.
+     * Checks if the mark is active in the current editor selection. If the
+     * optional `attrs` parameter is provided, it will check if the mark is active
+     * with the given attributes.
      */
-    type: string;
+    isActive: (attrs?: Attrs) => boolean;
+}
+export { MarkAction }
+export { MarkAction as MarkAction_alias_1 }
+
+/**
+ * @public
+ */
+declare interface MarkAttrOptions<MarkName extends string = string, AttrName extends string = string, AttrType = any> extends AttrSpec<AttrType> {
     /**
-     * The name of the attribute.
+     * The name of the mark type.
      */
-    attr: string;
+    type: MarkName;
     /**
-     * The default value for this attribute, to use when no explicit value is
-     * provided. Attributes that have no default must be provided whenever a mark
-     * of a type that has them is created.
+     * The name of the attribute.
      */
-    default?: any;
+    attr: AttrName;
     /**
      * Returns the attribute key and value to be set on the DOM node.
      */
@@ -1431,25 +1599,39 @@ export { MarkAttrOptions }
 export { MarkAttrOptions as MarkAttrOptions_alias_1 }
 
 /**
- * @public
+ * @deprecated Use type {@link MarkAction} instead.
  */
-declare interface MarkBuilder {
-    (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode[];
-    (...children: NodeChild[]): ProseMirrorNode[];
-    isActive: (attrs?: Attrs) => boolean;
-}
+declare type MarkBuilder = MarkAction;
 export { MarkBuilder }
 export { MarkBuilder as MarkBuilder_alias_1 }
 
 /**
  * @public
  */
-declare interface MarkSpecOptions<MarkName extends string = string> extends MarkSpec {
+declare interface MarkSpecOptions<MarkName extends string = string, Attrs extends AnyAttrs = AnyAttrs> extends MarkSpec {
+    /**
+     * The name of the mark type.
+     */
     name: MarkName;
+    /**
+     * The attributes that marks of this type get.
+     */
+    attrs?: {
+        [K in keyof Attrs]: AttrSpec<Attrs[K]>;
+    };
 }
 export { MarkSpecOptions }
 export { MarkSpecOptions as MarkSpecOptions_alias_1 }
 
+/**
+ * @internal
+ */
+declare interface MarkTyping {
+    [name: string]: Record<string, any>;
+}
+export { MarkTyping }
+export { MarkTyping as MarkTyping_alias_1 }
+
 /**
  * @internal
  */
@@ -1469,23 +1651,39 @@ export { MountHandler }
 export { MountHandler as MountHandler_alias_1 }
 
 /**
+ * A function for creating a node with optional attributes and any number of
+ * children.
+ *
+ * It also has a `isActive` method for checking if the node is active in the
+ * current editor selection.
+ *
  * @public
  */
-declare interface NodeAttrOptions {
+declare interface NodeAction<Attrs extends AnyAttrs = AnyAttrs> {
+    (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode;
+    (...children: NodeChild[]): ProseMirrorNode;
     /**
-     * The name of the node type.
+     * Checks if the node is active in the current editor selection. If the
+     * optional `attrs` parameter is provided, it will check if the node is active
+     * with the given attributes.
      */
-    type: string;
+    isActive: (attrs?: Attrs) => boolean;
+}
+export { NodeAction }
+export { NodeAction as NodeAction_alias_1 }
+
+/**
+ * @public
+ */
+declare interface NodeAttrOptions<NodeName extends string = string, AttrName extends string = string, AttrType = any> extends AttrSpec<AttrType> {
     /**
-     * The name of the attribute.
+     * The name of the node type.
      */
-    attr: string;
+    type: NodeName;
     /**
-     * The default value for this attribute, to use when no explicit value is
-     * provided. Attributes that have no default must be provided whenever a node
-     * of a type that has them is created.
+     * The name of the attribute.
      */
-    default?: any;
+    attr: AttrName;
     /**
      * Whether the attribute should be kept when the node is split. Set it to
      * `true` if you want to inherit the attribute from the previous node when
@@ -1510,20 +1708,20 @@ export { NodeAttrOptions }
 export { NodeAttrOptions as NodeAttrOptions_alias_1 }
 
 /**
- * @public
+ * @deprecated Use type {@link NodeAction} instead.
  */
-declare interface NodeBuilder {
-    (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode;
-    (...children: NodeChild[]): ProseMirrorNode;
-    isActive: (attrs?: Attrs) => boolean;
-}
+declare type NodeBuilder = NodeAction;
 export { NodeBuilder }
 export { NodeBuilder as NodeBuilder_alias_1 }
 
 /**
+ * Available children parameters for {@link NodeAction} and {@link MarkAction}.
+ *
  * @public
  */
-export declare type NodeChild = ProseMirrorNode | string | NodeChild[];
+declare type NodeChild = ProseMirrorNode | string | NodeChild[];
+export { NodeChild }
+export { NodeChild as NodeChild_alias_1 }
 
 /**
  * @public
@@ -1577,13 +1775,35 @@ export { NodeJSON as NodeJSON_alias_1 }
 /**
  * @public
  */
-declare interface NodeSpecOptions<NodeName extends string = string> extends NodeSpec {
+declare interface NodeSpecOptions<NodeName extends string = string, Attrs extends AnyAttrs = AnyAttrs> extends NodeSpec {
+    /**
+     * The name of the node type.
+     */
     name: NodeName;
+    /**
+     * Whether this is the top-level node type. Only one node type can be the
+     * top-level node type in a schema.
+     */
     topNode?: boolean;
+    /**
+     * The attributes that nodes of this type get.
+     */
+    attrs?: {
+        [key in keyof Attrs]: AttrSpec<Attrs[key]>;
+    };
 }
 export { NodeSpecOptions }
 export { NodeSpecOptions as NodeSpecOptions_alias_1 }
 
+/**
+ * @internal
+ */
+declare interface NodeTyping {
+    [name: string]: Record<string, any>;
+}
+export { NodeTyping }
+export { NodeTyping as NodeTyping_alias_1 }
+
 /**
  * @internal
  */
@@ -1648,14 +1868,14 @@ export declare type Payloads<T> = Tuple5<T[]>;
 /**
  * @internal
  */
-export declare type PickKnownCommandTyping<T extends CommandTyping> = [
-CommandTyping
-] extends [T] ? never : T;
+export declare type PickStringLiteral<T> = PickSubType<T, string>;
 
 /**
  * @internal
  */
-export declare type PickStringLiteral<T extends string> = [string] extends [T] ? never : T;
+declare type PickSubType<Type, ParentType> = Type extends ParentType ? [ParentType] extends [Type] ? never : Type : never;
+export { PickSubType }
+export { PickSubType as PickSubType_alias_1 }
 
 /**
  * @internal
@@ -1873,8 +2093,16 @@ export declare function setupEditorExtension<E extends Extension>(options: Edito
  */
 export declare function setupTest(): {
     editor: TestEditor<Extension<{
-        Nodes: "text" | "doc" | "paragraph" | "heading";
-        Marks: "bold" | "italic";
+        Nodes: SimplifyDeeper<    {
+        paragraph: Attrs_2;
+        doc: Attrs_2;
+        text: Attrs_2;
+        heading: Attrs_2;
+        }>;
+        Marks: SimplifyDeeper<    {
+        bold: Attrs_2;
+        italic: Attrs_2;
+        }>;
         Commands: {
             insertText: [{
                 text: string;
@@ -1891,12 +2119,32 @@ export declare function setupTest(): {
             removeMark: [options: RemoveMarkOptions];
             unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
             unsetMark: [options?: UnsetMarkOptions | undefined];
-            undo: [];
-            redo: [];
+            readonly undo: [];
+            readonly redo: [];
         };
     }>>;
-    n: Record<"text" | "doc" | "paragraph" | "heading", NodeBuilder>;
-    m: Record<"bold" | "italic", MarkBuilder>;
+    n: ToNodeAction<SimplifyDeeper<    {
+    paragraph: {
+    readonly [x: string]: any;
+    };
+    doc: {
+    readonly [x: string]: any;
+    };
+    text: {
+    readonly [x: string]: any;
+    };
+    heading: {
+    readonly [x: string]: any;
+    };
+    }>>;
+    m: ToMarkAction<SimplifyDeeper<    {
+    bold: {
+    readonly [x: string]: any;
+    };
+    italic: {
+    readonly [x: string]: any;
+    };
+    }>>;
 };
 
 /**
@@ -1904,9 +2152,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>;
+};
+
+/**
+ * @internal
+ */
+declare type SimplifyDeeper<T> = {
+    [KeyType in keyof T]: Simplify<T[KeyType]>;
 };
+export { SimplifyDeeper }
+export { SimplifyDeeper as SimplifyDeeper_alias_1 }
 
 /**
  * @internal
@@ -2008,8 +2265,8 @@ declare type TextInputHandler = (view: EditorView, from: number, to: number, tex
 export { TextInputHandler }
 export { TextInputHandler as TextInputHandler_alias_1 }
 
-export declare type ToCommandApplier<T extends CommandTyping> = {
-    [K in keyof T]: CommandApplier<T[K]>;
+export declare type ToCommandAction<T extends CommandTyping> = {
+    [K in keyof T]: CommandAction<T[K]>;
 };
 
 export declare type ToCommandCreators<T extends CommandTyping> = {
@@ -2061,6 +2318,24 @@ declare interface ToggleNodeOptions {
 export { ToggleNodeOptions }
 export { ToggleNodeOptions as ToggleNodeOptions_alias_1 }
 
+/**
+ * @internal
+ */
+declare type ToMarkAction<T extends MarkTyping> = {
+    [K in keyof T]: MarkAction<T[K]>;
+};
+export { ToMarkAction }
+export { ToMarkAction as ToMarkAction_alias_1 }
+
+/**
+ * @internal
+ */
+declare type ToNodeAction<T extends NodeTyping> = {
+    [K in keyof T]: NodeAction<T[K]>;
+};
+export { ToNodeAction }
+export { ToNodeAction as ToNodeAction_alias_1 }
+
 export declare function toReversed<T>(arr: T[]): T[];
 
 declare type TripleClickHandler = (view: EditorView, pos: number, event: MouseEvent) => boolean | void;