@prosekit/core 0.0.0-next-20240715071354 → 0.0.0-next-20240724172520

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,59 @@ 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
+ */
+declare type BaseCommandsExtension = Extension<{
+    Commands: {
+        insertText: [options: InsertTextOptions];
+        insertNode: [options: InsertNodeOptions];
+        removeNode: [options: RemoveNodeOptions];
+        wrap: [options: WrapOptions];
+        setBlockType: [options: SetBlockTypeOptions];
+        setNodeAttrs: [options: SetNodeAttrsOptions];
+        selectAll: [];
+        addMark: [options: AddMarkOptions];
+        removeMark: [options: RemoveMarkOptions];
+        unsetBlockType: [options?: UnsetBlockTypeOptions];
+        unsetMark: [options?: UnsetMarkOptions];
+    };
+}>;
+export { BaseCommandsExtension }
+export { BaseCommandsExtension as BaseCommandsExtension_alias_1 }
+
 /**
  * @internal
  */
@@ -131,6 +192,17 @@ export declare abstract class BaseExtension<T extends ExtensionTyping = Extensio
     get schema(): Schema | null;
 }
 
+/**
+ * @internal
+ */
+declare type BaseKeymapExtension = Extension<{
+    Nodes: never;
+    Commands: never;
+    Keymap: never;
+}>;
+export { BaseKeymapExtension }
+export { BaseKeymapExtension as BaseKeymapExtension_alias_1 }
+
 /**
  * Some basic props for custom node views.
  *
@@ -199,10 +271,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;
 
@@ -223,6 +304,13 @@ declare interface CommandTyping {
 export { CommandTyping }
 export { CommandTyping as CommandTyping_alias_1 }
 
+/**
+ * @internal
+ */
+declare function containsInlineNode(doc: ProseMirrorNode, from: number, to: number): boolean;
+export { containsInlineNode }
+export { containsInlineNode as containsInlineNode_alias_1 }
+
 /**
  * @public
  */
@@ -233,12 +321,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;
 
@@ -292,27 +380,7 @@ export { DefaultStateOptions as DefaultStateOptions_alias_1 }
  *
  * @public
  */
-declare function defineBaseCommands(): 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;
-}>;
+declare function defineBaseCommands(): BaseCommandsExtension;
 export { defineBaseCommands }
 export { defineBaseCommands as defineBaseCommands_alias_1 }
 
@@ -328,7 +396,7 @@ declare function defineBaseKeymap(options?: {
      * @default Priority.low
      */
     priority?: Priority;
-}): Extension<ExtensionTyping<any, any, any>>;
+}): BaseKeymapExtension;
 export { defineBaseKeymap }
 export { defineBaseKeymap as defineBaseKeymap_alias_1 }
 
@@ -354,8 +422,6 @@ declare function defineCommands<T extends Record<string, CommandCreator> = Recor
     Commands: {
         [K in keyof T]: Parameters<T[K]>;
     };
-    Nodes: never;
-    Marks: never;
 }>;
 export { defineCommands }
 export { defineCommands as defineCommands_alias_1 }
@@ -367,11 +433,7 @@ export { defineDefaultState as defineDefaultState_alias_1 }
 /**
  * @public
  */
-declare function defineDoc(): Extension<    {
-Nodes: "doc";
-Marks: never;
-Commands: never;
-}>;
+declare function defineDoc(): DocExtension;
 export { defineDoc }
 export { defineDoc as defineDoc_alias_1 }
 
@@ -468,14 +530,7 @@ export { defineFocusChangeHandler as defineFocusChangeHandler_alias_1 }
  *
  * @public
  */
-declare function defineHistory({ depth, newGroupDelay, }?: HistoryOptions): Extension<    {
-Nodes: never;
-Marks: never;
-Commands: {
-readonly undo: [];
-readonly redo: [];
-};
-}>;
+declare function defineHistory({ depth, newGroupDelay, }?: HistoryOptions): HistoryExtension;
 export { defineHistory }
 export { defineHistory as defineHistory_alias_1 }
 
@@ -507,17 +562,21 @@ 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<{
+    Marks: {
+        [K in MarkType]: AttrType;
+    };
+}>;
 export { defineMarkAttr }
 export { defineMarkAttr as defineMarkAttr_alias_1 }
 
 /**
  * @public
  */
-declare function defineMarkSpec<Mark extends string>(options: MarkSpecOptions<Mark>): Extension<{
-    Marks: Mark;
-    Nodes: never;
-    Commands: never;
+declare function defineMarkSpec<Mark extends string, Attrs extends AnyAttrs = AnyAttrs>(options: MarkSpecOptions<Mark, Attrs>): Extension<{
+    Marks: {
+        [K in Mark]: Attrs;
+    };
 }>;
 export { defineMarkSpec }
 export { defineMarkSpec as defineMarkSpec_alias_1 }
@@ -536,7 +595,13 @@ 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;
+        };
+    };
+}>;
 export { defineNodeAttr }
 export { defineNodeAttr as defineNodeAttr_alias_1 }
 
@@ -545,10 +610,10 @@ export { defineNodeAttr as defineNodeAttr_alias_1 }
  *
  * @public
  */
-declare function defineNodeSpec<Node extends string>(options: NodeSpecOptions<Node>): Extension<{
-    Nodes: Node;
-    Marks: never;
-    Commands: never;
+declare function defineNodeSpec<Node extends string, Attrs extends AnyAttrs = AnyAttrs>(options: NodeSpecOptions<Node, Attrs>): Extension<{
+    Nodes: {
+        [K in Node]: Attrs;
+    };
 }>;
 export { defineNodeSpec }
 export { defineNodeSpec as defineNodeSpec_alias_1 }
@@ -576,11 +641,7 @@ 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";
-Marks: never;
-Commands: never;
-}>;
+declare function defineParagraph(): ParagraphExtension;
 export { defineParagraph }
 export { defineParagraph as defineParagraph_alias_1 }
 
@@ -589,11 +650,7 @@ export { defineParagraph as defineParagraph_alias_1 }
  *
  * Defines a paragraph node spec.
  */
-export declare function defineParagraphSpec(): Extension<    {
-Nodes: "paragraph";
-Marks: never;
-Commands: never;
-}>;
+export declare function defineParagraphSpec(): ParagraphSpecExtension;
 
 /**
  * @public
@@ -614,7 +671,7 @@ export { definePasteHandler as definePasteHandler_alias_1 }
  */
 declare function definePlugin(plugin: Plugin_2 | Plugin_2[] | ((context: {
     schema: Schema;
-}) => Plugin_2 | Plugin_2[])): Extension;
+}) => Plugin_2 | Plugin_2[])): PluginExtension;
 export { definePlugin }
 export { definePlugin as definePlugin_alias_1 }
 
@@ -630,38 +687,34 @@ export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_
 /**
  * @internal
  */
-export declare function defineTestExtension(): Extension<{
-    Nodes: "text" | "doc" | "paragraph" | "heading";
-    Marks: "bold" | "italic";
-    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: [];
-    };
-}>;
+export declare function defineTestExtension(): Union<readonly [BaseCommandsExtension, BaseKeymapExtension, DocExtension, HistoryExtension, Extension<{
+Nodes: {
+paragraph: Attrs_2;
+};
+}>, TextExtension, Extension<{
+Marks: {
+bold: Attrs_2;
+};
+}>, Extension<{
+Marks: {
+italic: Attrs_2;
+};
+}>, Extension<{
+Nodes: {
+heading: Attrs_2;
+};
+}>, Extension<{
+Nodes: {
+codeBlock: {
+language: string;
+};
+};
+}>]>;
 
 /**
  * @public
  */
-declare function defineText(): Extension<    {
-Nodes: "text";
-Marks: never;
-Commands: never;
-}>;
+declare function defineText(): TextExtension;
 export { defineText }
 export { defineText as defineText_alias_1 }
 
@@ -722,6 +775,17 @@ declare type DocChangeHandler = (view: EditorView, prevState: EditorState) => vo
 export { DocChangeHandler }
 export { DocChangeHandler as DocChangeHandler_alias_1 }
 
+/**
+ * @internal
+ */
+declare type DocExtension = Extension<{
+    Nodes: {
+        doc: Attrs;
+    };
+}>;
+export { DocExtension }
+export { DocExtension as DocExtension_alias_1 }
+
 /**
  * @internal
  */
@@ -811,11 +875,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.
      */
@@ -855,8 +915,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 }
@@ -867,9 +937,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);
@@ -988,18 +1058,27 @@ 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> {
-    Nodes: N;
-    Marks: M;
-    Commands: C;
+declare interface ExtensionTyping<N extends NodeTyping | never = never, M extends MarkTyping | never = never, C extends CommandTyping | never = never> {
+    Nodes?: N;
+    Marks?: M;
+    Commands?: C;
 }
 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 }
 
@@ -1015,17 +1094,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
+ */
+export declare type ExtractMarkNames<E extends Extension> = PickStringLiteral<keyof ExtractMarks<E>>;
+
 /**
  * @public
  */
-declare type ExtractMarks<E extends Extension> = ExtractTyping<E>['Marks'];
+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 ExtractNodes<E extends Extension> = ExtractTyping<E>['Nodes'];
+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> = SimplifyDeeper<SimplifyUnion<ExtractTyping<E>['Nodes']>>;
 export { ExtractNodes }
 export { ExtractNodes as ExtractNodes_alias_1 }
 
@@ -1034,7 +1141,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
@@ -1173,6 +1280,18 @@ export declare type GroupedEntries<T extends Record<string, any>> = {
 
 export declare function groupEntries<T extends Record<string, any>>(entries: ObjectEntries<T>[]): GroupedEntries<T>;
 
+/**
+ * @internal
+ */
+declare type HistoryExtension = Extension<{
+    Commands: {
+        undo: [];
+        redo: [];
+    };
+}>;
+export { HistoryExtension }
+export { HistoryExtension as HistoryExtension_alias_1 }
+
 /**
  * Options for {@link defineHistory}.
  *
@@ -1220,6 +1339,8 @@ declare function htmlFromNode(node: ProseMirrorNode, options?: DOMSerializerOpti
 export { htmlFromNode }
 export { htmlFromNode as htmlFromNode_alias_1 }
 
+export declare function includesMark(marks: readonly Mark[], markType: MarkType, attrs?: Attrs | null): boolean;
+
 /**
  * Returns a command that inserts the given node at the current selection or at
  * the given position.
@@ -1265,11 +1386,16 @@ export { InsertNodeOptions as InsertNodeOptions_alias_1 }
  *
  * @public
  */
-export declare function insertText({ text, from, to, }: {
+export declare function insertText({ text, from, to }: InsertTextOptions): Command;
+
+/**
+ * @public
+ */
+export declare type InsertTextOptions = {
     text: string;
     from?: number;
     to?: number;
-}): Command;
+};
 
 /**
  * @internal
@@ -1315,6 +1441,7 @@ export { isMark as isMark_alias_1 }
 /**
  * Returns true if the given mark is missing in some part of the range.
  * Returns false if the entire range has the given mark.
+ * Returns true if the mark is not allowed in the range.
  *
  * @internal
  */
@@ -1347,6 +1474,13 @@ declare function isProseMirrorNode(node: unknown): node is ProseMirrorNode;
 export { isProseMirrorNode }
 export { isProseMirrorNode as isProseMirrorNode_alias_1 }
 
+/**
+ * Check if `subset` is a subset of `superset`.
+ *
+ * @internal
+ */
+export declare function isSubset(subset: Record<string, unknown>, superset: Record<string, unknown>): boolean;
+
 /**
  * @internal
  */
@@ -1427,23 +1561,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.
      */
@@ -1457,25 +1607,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
  */
@@ -1495,23 +1659,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
@@ -1536,20 +1716,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
@@ -1603,13 +1783,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
  */
@@ -1662,6 +1864,22 @@ export declare type ObjectEntries<T extends Record<string, any>> = {
 
 export declare function objectEqual<T>(a: T, b: T): boolean;
 
+/**
+ * @internal
+ */
+declare type ParagraphExtension = ParagraphSpecExtension;
+export { ParagraphExtension }
+export { ParagraphExtension as ParagraphExtension_alias_1 }
+
+/**
+ * @internal
+ */
+declare type ParagraphSpecExtension = Extension<{
+    Nodes: {
+        paragraph: Attrs;
+    };
+}>;
+
 declare type PasteHandler = (view: EditorView, event: ClipboardEvent, slice: Slice) => boolean | void;
 export { PasteHandler }
 export { PasteHandler as PasteHandler_alias_1 }
@@ -1674,14 +1892,25 @@ 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
+ */
+declare type PluginExtension = Extension<{
+    Nodes: never;
+    Marks: never;
+    Commands: never;
+}>;
+export { PluginExtension }
+export { PluginExtension as PluginExtension_alias_1 }
 
 /**
  * @internal
@@ -1898,31 +2127,57 @@ export declare function setupEditorExtension<E extends Extension>(options: Edito
  * @internal
  */
 export declare function setupTest(): {
-    editor: TestEditor<Extension<{
-        Nodes: "text" | "doc" | "paragraph" | "heading";
-        Marks: "bold" | "italic";
-        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: [];
-        };
+    editor: TestEditor<Union<readonly [BaseCommandsExtension, BaseKeymapExtension, DocExtension, HistoryExtension, Extension<{
+    Nodes: {
+    paragraph: Attrs_2;
+    };
+    }>, TextExtension, Extension<{
+    Marks: {
+    bold: Attrs_2;
+    };
+    }>, Extension<{
+    Marks: {
+    italic: Attrs_2;
+    };
+    }>, Extension<{
+    Nodes: {
+    heading: Attrs_2;
+    };
+    }>, Extension<{
+    Nodes: {
+    codeBlock: {
+    language: string;
+    };
+    };
+    }>]>>;
+    m: ToMarkAction<SimplifyDeeper<    {
+    bold: {
+    readonly [x: string]: any;
+    };
+    italic: {
+    readonly [x: string]: any;
+    };
     }>>;
-    n: Record<"text" | "doc" | "paragraph" | "heading", NodeBuilder>;
-    m: Record<"bold" | "italic", MarkBuilder>;
+    n: {
+        p: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        doc: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        paragraph: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        text: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        codeBlock: NodeAction<    {
+        language: string;
+        }>;
+        heading: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+    };
 };
 
 /**
@@ -1930,14 +2185,23 @@ 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
  */
-declare type SimplifyUnion<T> = Simplify<UnionToIntersection<T>>;
+declare type SimplifyUnion<T> = Simplify<UnionToIntersection<T extends undefined ? never : T>>;
 export { SimplifyUnion }
 export { SimplifyUnion as SimplifyUnion_alias_1 }
 
@@ -2030,12 +2294,23 @@ declare class TestEditor<E extends Extension = Extension> extends Editor<E> {
 export { TestEditor }
 export { TestEditor as TestEditor_alias_1 }
 
+/**
+ * @internal
+ */
+declare type TextExtension = Extension<{
+    Nodes: {
+        text: Attrs;
+    };
+}>;
+export { TextExtension }
+export { TextExtension as TextExtension_alias_1 }
+
 declare type TextInputHandler = (view: EditorView, from: number, to: number, text: string) => boolean | void;
 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> = {
@@ -2087,6 +2362,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;
@@ -2102,6 +2395,17 @@ export { TripleClickOnHandler as TripleClickOnHandler_alias_1 }
  */
 export declare type Tuple5<T> = [T, T, T, T, T];
 
+/**
+ * @internal
+ */
+declare type Union<E extends readonly Extension[]> = Extension<{
+    Nodes: ExtractNodes<E[number]>;
+    Marks: ExtractMarks<E[number]>;
+    Commands: ExtractCommands<E[number]>;
+}>;
+export { Union }
+export { Union as Union_alias_1 }
+
 /**
  * Merge multiple extensions into one.
  *
@@ -2120,11 +2424,14 @@ export declare type Tuple5<T> = [T, T, T, T, T];
  *
  * @public
  */
-declare function union<const E extends Extension | readonly Extension[]>(extension: E): UnionExtension<E>;
+declare function union<const E extends readonly Extension[]>(...exts: E): Union<E>;
+
+declare function union<const E extends readonly Extension[]>(exts: E): Union<E>;
 export { union }
 export { union as union_alias_1 }
 
 /**
+ * @deprecated Use `Union` instead.
  * @internal
  */
 declare type UnionExtension<E extends Extension | readonly Extension[]> = E extends readonly Extension[] ? Extension<{