@prosekit/core 0.0.0-next-20240715062625 → 0.0.0-next-20240724155246

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;
 
@@ -223,6 +272,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 +289,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 +424,9 @@ export { defineDefaultState as defineDefaultState_alias_1 }
  * @public
  */
 declare function defineDoc(): Extension<    {
-Nodes: "doc";
+Nodes: {
+doc: Attrs_2;
+};
 Marks: never;
 Commands: never;
 }>;
@@ -468,14 +526,14 @@ export { defineFocusChangeHandler as defineFocusChangeHandler_alias_1 }
  *
  * @public
  */
-declare function defineHistory({ depth, newGroupDelay, }?: HistoryOptions): Extension<    {
-Nodes: never;
-Marks: never;
+declare function defineHistory({ depth, newGroupDelay, }?: HistoryOptions): UnionExtension<readonly [Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<    {
 Commands: {
 readonly undo: [];
 readonly redo: [];
 };
-}>;
+Nodes: never;
+Marks: never;
+}>]>;
 export { defineHistory }
 export { defineHistory as defineHistory_alias_1 }
 
@@ -507,15 +565,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;
 }>;
@@ -536,7 +602,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 }
 
@@ -545,8 +619,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;
 }>;
@@ -577,7 +653,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;
 }>;
@@ -590,7 +668,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;
 }>;
@@ -630,35 +710,86 @@ 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(): UnionExtension<readonly [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;
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<{
+Nodes: {
+doc: Attrs_2;
+};
+Marks: never;
+Commands: never;
+}>, UnionExtension<readonly [Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<{
+Commands: {
+readonly undo: [];
+readonly redo: [];
+};
+Nodes: never;
+Marks: never;
+}>]>, Extension<{
+Nodes: {
+paragraph: Attrs_2;
+};
+Marks: never;
+Commands: never;
+}>, Extension<{
+Nodes: {
+text: Attrs_2;
+};
+Marks: never;
+Commands: never;
+}>, Extension<{
+Marks: {
+bold: Attrs_2;
+};
+Nodes: never;
+Commands: never;
+}>, Extension<{
+Marks: {
+italic: Attrs_2;
+};
+Nodes: never;
+Commands: never;
+}>, Extension<{
+Nodes: {
+heading: Attrs_2;
+};
+Marks: never;
+Commands: never;
+}>, Extension<{
+Nodes: {
+codeBlock: {
+language: string;
+};
+};
+Marks: never;
+Commands: never;
+}>]>;
 
 /**
  * @public
  */
 declare function defineText(): Extension<    {
-Nodes: "text";
+Nodes: {
+text: Attrs_2;
+};
 Marks: never;
 Commands: never;
 }>;
@@ -811,11 +942,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 +982,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 +1004,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,7 +1125,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;
@@ -997,9 +1134,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 }
 
@@ -1015,17 +1161,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 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 }
 
@@ -1034,7 +1208,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
@@ -1220,6 +1394,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.
@@ -1315,6 +1491,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 +1524,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 +1611,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 +1657,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 +1709,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 +1766,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 +1833,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
  */
@@ -1674,14 +1926,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
@@ -1898,31 +2150,106 @@ 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<UnionExtension<readonly [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;
+    }>, Extension<ExtensionTyping<any, any, any>>, Extension<{
+    Nodes: {
+    doc: Attrs_2;
+    };
+    Marks: never;
+    Commands: never;
+    }>, UnionExtension<readonly [Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<{
+    Commands: {
+    readonly undo: [];
+    readonly redo: [];
+    };
+    Nodes: never;
+    Marks: never;
+    }>]>, Extension<{
+    Nodes: {
+    paragraph: Attrs_2;
+    };
+    Marks: never;
+    Commands: never;
+    }>, Extension<{
+    Nodes: {
+    text: Attrs_2;
+    };
+    Marks: never;
+    Commands: never;
+    }>, Extension<{
+    Marks: {
+    bold: Attrs_2;
+    };
+    Nodes: never;
+    Commands: never;
+    }>, Extension<{
+    Marks: {
+    italic: Attrs_2;
+    };
+    Nodes: never;
+    Commands: never;
+    }>, Extension<{
+    Nodes: {
+    heading: Attrs_2;
+    };
+    Marks: never;
+    Commands: never;
+    }>, Extension<{
+    Nodes: {
+    codeBlock: {
+    language: string;
+    };
+    };
+    Marks: never;
+    Commands: never;
+    }>]>>;
+    m: ToMarkAction<SimplifyDeeper<    {
+    italic: {
+    readonly [x: string]: any;
+    };
+    bold: {
+    readonly [x: string]: any;
+    };
     }>>;
-    n: Record<"text" | "doc" | "paragraph" | "heading", NodeBuilder>;
-    m: Record<"bold" | "italic", MarkBuilder>;
+    n: {
+        p: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        paragraph: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        codeBlock: NodeAction<    {
+        language: string;
+        }>;
+        heading: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        text: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        doc: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+    };
 };
 
 /**
@@ -1930,9 +2257,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
@@ -2034,8 +2370,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> = {
@@ -2087,6 +2423,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;
@@ -2120,18 +2474,20 @@ 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 Extensions extends readonly Extension[]>(...exts: Extensions): UnionExtension<Extensions>;
+
+declare function union<const Extensions extends readonly Extension[]>(exts: Extensions): UnionExtension<Extensions>;
 export { union }
 export { union as union_alias_1 }
 
 /**
  * @internal
  */
-declare type UnionExtension<E extends Extension | readonly Extension[]> = E extends readonly Extension[] ? Extension<{
+declare type UnionExtension<E extends readonly Extension[]> = Extension<{
     Nodes: ExtractNodes<E[number]>;
     Marks: ExtractMarks<E[number]>;
     Commands: ExtractCommands<E[number]>;
-}> : E;
+}>;
 export { UnionExtension }
 export { UnionExtension as UnionExtension_alias_1 }