@prosekit/core 0.7.6 → 0.7.8

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

@@ -1,16 +1,17 @@
 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';
 import type { DirectEditorProps } from '@prosekit/pm/view';
 import type { DOMEventMap } from '@prosekit/pm/view';
+import type { DOMOutputSpec } from '@prosekit/pm/model';
 import { DOMParser as DOMParser_2 } from '@prosekit/pm/model';
 import { DOMSerializer } from '@prosekit/pm/model';
 import { EditorState } from '@prosekit/pm/state';
 import type { EditorStateConfig } from '@prosekit/pm/state';
 import { EditorView } from '@prosekit/pm/view';
+import { Fragment } from '@prosekit/pm/model';
 import type { IsEqual } from 'type-fest';
 import { Mark } from '@prosekit/pm/model';
 import type { MarkSpec } from '@prosekit/pm/model';
@@ -33,7 +34,8 @@ import { SchemaSpec } from '@prosekit/pm/model';
 import { Selection as Selection_2 } from '@prosekit/pm/state';
 import { Selection as Selection_3 } from 'prosemirror-state';
 import type { Simplify } from 'type-fest';
-import type { Slice } from '@prosekit/pm/model';
+import { Slice } from '@prosekit/pm/model';
+import type { TagParseRule } from '@prosekit/pm/model';
 import { TextSelection } from '@prosekit/pm/state';
 import { Transaction } from '@prosekit/pm/state';
 import type { UnionToIntersection } from 'type-fest';
@@ -121,6 +123,12 @@ export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
  */
 export declare function assertTypeEqual_alias_1<T, U>(_val: IsEqual<T, U>): void;
 
+declare interface AttrOptions {
+    attr: string;
+    toDOM?: (value: unknown) => [key: string, value: string] | null | undefined;
+    parseDOM?: (node: HTMLElement) => unknown;
+}
+
 export declare function attrsMatch(nodeOrMark: ProseMirrorNode | Mark, attrs: Attrs): boolean;
 
 /**
@@ -225,9 +233,11 @@ declare interface BaseNodeViewOptions {
 export { BaseNodeViewOptions }
 export { BaseNodeViewOptions as BaseNodeViewOptions_alias_1 }
 
-export declare function baseToggleMark(markType: MarkType, attrs?: Attrs | null, options?: {
-    removeWhenPresent: boolean;
-}): Command;
+declare type BoldExtension = Extension<{
+    Marks: {
+        bold: Attrs;
+    };
+}>;
 
 export declare function buildNode(type: NodeType, args: [Attrs | NodeChild | null | undefined, ...NodeChild[]], createNode: CreateNodeFunction): ProseMirrorNode;
 
@@ -256,9 +266,28 @@ declare const clsx: (...args: Array<string | boolean | null | undefined>) => str
 export { clsx }
 export { clsx as clsx_alias_1 }
 
+declare type CodeBlockExtension = Extension<{
+    Nodes: {
+        codeBlock: {
+            language: string;
+        };
+    };
+}>;
+
+/**
+ * Collects all children of a node or a fragment, and returns them as an array.
+ *
+ * @public
+ */
+declare function collectChildren(parent: ProseMirrorNode | Fragment): ProseMirrorNode[];
+export { collectChildren }
+export { collectChildren as collectChildren_alias_1 }
+
 /**
  * Collects all nodes from a given content.
  *
+ * @deprecated Use `collectChildren` instead.
+ *
  * @public
  */
 declare function collectNodes(content: NodeContent): ProseMirrorNode[];
@@ -317,12 +346,12 @@ export { createEditor as createEditor_alias_1 }
 /**
  * @internal
  */
-export declare function createMarkActions(schema: Schema, getState: () => EditorState | null | undefined, applyMark?: ApplyMarkFunction): Record<string, MarkAction>;
+export declare function createMarkActions(schema: Schema, getState: GetStateFunction, applyMark?: ApplyMarkFunction): Record<string, MarkAction>;
 
 /**
  * @internal
  */
-export declare function createNodeActions(schema: Schema, getState: () => EditorState | null | undefined, createNode?: CreateNodeFunction): Record<string, NodeAction>;
+export declare function createNodeActions(schema: Schema, getState: GetStateFunction, createNode?: CreateNodeFunction): Record<string, NodeAction>;
 
 export declare const createNodeForTest: CreateNodeFunction;
 
@@ -351,20 +380,32 @@ declare function defaultBlockAt(match: ContentMatch): NodeType_2 | null;
 export { defaultBlockAt }
 export { defaultBlockAt as defaultBlockAt_alias_1 }
 
+/**
+ * @public
+ */
 declare interface DefaultStateOptions {
+    /**
+     * The starting document to use when creating the editor. It can be a
+     * ProseMirror node JSON object, a HTML string, or a HTML element instance.
+     */
+    defaultContent?: NodeJSON | string | HTMLElement;
     /**
      * A JSON object representing the starting document to use when creating the
      * editor.
+     *
+     * @deprecated Use `defaultContent` instead.
      */
     defaultDoc?: NodeJSON;
     /**
      * A HTML element or a HTML string representing the starting document to use
      * when creating the editor.
+     *
+     * @deprecated Use `defaultContent` instead.
      */
     defaultHTML?: string | HTMLElement;
     /**
      * A JSON object representing the starting selection to use when creating the
-     * editor. It's only used when `defaultDoc` or `defaultHTML` is also provided.
+     * editor. It's only used when `defaultContent` is also provided.
      */
     defaultSelection?: SelectionJSON;
 }
@@ -422,7 +463,14 @@ declare function defineCommands<T extends Record<string, CommandCreator> = Recor
 export { defineCommands }
 export { defineCommands as defineCommands_alias_1 }
 
-declare function defineDefaultState({ defaultDoc, defaultHTML, defaultSelection, }: DefaultStateOptions): PlainExtension;
+/**
+ * Define a default state for the editor.
+ *
+ * @param options
+ *
+ * @public
+ */
+declare function defineDefaultState({ defaultSelection, defaultContent, defaultDoc, defaultHTML, }: DefaultStateOptions): PlainExtension;
 export { defineDefaultState }
 export { defineDefaultState as defineDefaultState_alias_1 }
 
@@ -524,6 +572,8 @@ export { defineFocusChangeHandler as defineFocusChangeHandler_alias_1 }
 /**
  * Add undo/redo history to the editor.
  *
+ * @param options
+ *
  * @public
  */
 declare function defineHistory({ depth, newGroupDelay, }?: HistoryOptions): HistoryExtension;
@@ -685,27 +735,9 @@ export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_
  */
 export declare function defineTestExtension(): Union<readonly [BaseCommandsExtension, PlainExtension, 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;
-};
+paragraph: Attrs;
 };
-}>]>;
+}>, TextExtension, BoldExtension, ItalicExtension, LinkExtension, HeadingExtension, CodeBlockExtension]>;
 
 /**
  * @public
@@ -851,15 +883,10 @@ export { DropHandler as DropHandler_alias_1 }
  */
 declare class Editor<E extends Extension = any> {
     private instance;
-    private afterMounted;
     /**
      * @internal
      */
     constructor(instance: EditorInstance);
-    /**
-     * @internal
-     */
-    static create(instance: any): Editor;
     /**
      * Whether the editor is mounted.
      */
@@ -872,6 +899,10 @@ declare class Editor<E extends Extension = any> {
      * The editor schema.
      */
     get schema(): Schema<ExtractNodeNames<E>, ExtractMarkNames<E>>;
+    /**
+     * The editor's current state.
+     */
+    get state(): EditorState;
     /**
      * Whether the editor is focused.
      */
@@ -880,28 +911,24 @@ declare class Editor<E extends Extension = any> {
      * Mount the editor to the given HTML element.
      * Pass `null` or `undefined` to unmount the editor.
      */
-    mount(place: HTMLElement | null | undefined): void;
+    mount: (place: HTMLElement | null | undefined) => void;
     /**
      * Unmount the editor. This is equivalent to `mount(null)`.
      */
-    unmount(): void;
+    unmount: () => void;
     /**
      * Focus the editor.
      */
-    focus(): void;
+    focus: () => void;
     /**
      * Blur the editor.
      */
-    blur(): void;
+    blur: () => void;
     /**
      * Register an extension to the editor. Return a function to unregister the
      * extension.
      */
-    use(extension: Extension): VoidFunction;
-    /**
-     * The editor's current state.
-     */
-    get state(): EditorState;
+    use: (extension: Extension) => VoidFunction;
     /**
      * Update the editor's state.
      *
@@ -910,7 +937,22 @@ declare class Editor<E extends Extension = any> {
      * This is an advanced method. Use it only if you have a specific reason to
      * directly manipulate the editor's state.
      */
-    updateState(state: EditorState): void;
+    updateState: (state: EditorState) => void;
+    /**
+     * Update the editor's document and selection.
+     *
+     * @param content - The new document to set. It can be one of the following:
+     *   - A ProseMirror node instance
+     *   - A ProseMirror node JSON object
+     *   - An HTML string
+     *   - An HTML element instance
+     * @param selection - Optional. Specifies the new selection. It can be one of the following:
+     *   - A ProseMirror selection instance
+     *   - A ProseMirror selection JSON object
+     *   - The string "start" (to set selection at the beginning, default value)
+     *   - The string "end" (to set selection at the end)
+     */
+    setContent: (content: ProseMirrorNode | NodeJSON | string | HTMLElement, selection?: SelectionJSON | Selection_2 | "start" | "end") => void;
     /**
      * All {@link CommandAction}s defined by the editor.
      */
@@ -928,6 +970,8 @@ export { Editor }
 export { Editor as Editor_alias_1 }
 
 /**
+ * An internal class to make TypeScript generic type easier to use.
+ *
  * @internal
  */
 export declare class EditorInstance {
@@ -938,10 +982,13 @@ export declare class EditorInstance {
     commands: Record<string, CommandAction>;
     private tree;
     private directEditorProps;
+    private afterMounted;
     constructor(extension: Extension);
     getState: () => EditorState;
     updateState(state: EditorState): void;
-    updateExtension(extension: Extension, add: boolean): void;
+    setContent(content: NodeJSON | string | HTMLElement | ProseMirrorNode, selection?: SelectionJSON | Selection_2 | 'start' | 'end'): void;
+    private updateExtension;
+    use(extension: Extension): VoidFunction;
     mount(place: HTMLElement): void;
     unmount(): void;
     get mounted(): boolean;
@@ -969,19 +1016,28 @@ declare interface EditorOptions<E extends Extension> {
      * The extension to use when creating the editor.
      */
     extension: E;
+    /**
+     * The starting document to use when creating the editor. It can be a
+     * ProseMirror node JSON object, a HTML string, or a HTML element instance.
+     */
+    defaultContent?: NodeJSON | string | HTMLElement;
     /**
      * A JSON object representing the starting document to use when creating the
      * editor.
+     *
+     * @deprecated Use `defaultContent` instead.
      */
     defaultDoc?: NodeJSON;
     /**
      * A HTML element or a HTML string representing the starting document to use
      * when creating the editor.
+     *
+     * @deprecated Use `defaultContent` instead.
      */
     defaultHTML?: string | HTMLElement;
     /**
      * A JSON object representing the starting selection to use when creating the
-     * editor. It's only used when `defaultDoc` or `defaultHTML` is also provided.
+     * editor. It's only used when `defaultContent` is also provided.
      */
     defaultSelection?: SelectionJSON;
 }
@@ -1216,10 +1272,63 @@ export declare function findBrowserWindow(options?: {
     document?: Document;
 }): (Window & typeof globalThis) | null | undefined;
 
-export declare function findParentNode(nodeType: NodeType, $pos: ResolvedPos): {
-    from: number | null;
-    to: number | null;
-};
+/**
+ * Find the closest parent node that satisfies the predicate.
+ *
+ * @public
+ */
+declare function findParentNode(
+/**
+ * The predicate to test the parent node.
+ */
+predicate: (node: ProseMirrorNode) => boolean, 
+/**
+ * The position to start searching from.
+ */
+$pos: ResolvedPos): FindParentNodeResult | undefined;
+export { findParentNode }
+export { findParentNode as findParentNode_alias_1 }
+
+/**
+ * Finds the closest parent node that matches the given node type.
+ *
+ * @public
+ */
+declare function findParentNodeOfType(
+/**
+ * The type of the node to remove.
+ */
+type: NodeType | string, 
+/**
+ * The position to start searching from.
+ */
+$pos: ResolvedPos): FindParentNodeResult | undefined;
+export { findParentNodeOfType }
+export { findParentNodeOfType as findParentNodeOfType_alias_1 }
+
+/**
+ * @public
+ */
+declare interface FindParentNodeResult {
+    /**
+     * The closest parent node that satisfies the predicate.
+     */
+    node: ProseMirrorNode;
+    /**
+     * The position directly before the node.
+     */
+    pos: number;
+    /**
+     * The position at the start of the node.
+     */
+    start: number;
+    /**
+     * The depth of the node.
+     */
+    depth: number;
+}
+export { FindParentNodeResult }
+export { FindParentNodeResult as FindParentNodeResult_alias_1 }
 
 /**
  * A function that is called when the editor gains or loses focus.
@@ -1242,6 +1351,14 @@ export declare function getBrowserWindow(options?: {
 
 export declare function getCustomSelection(state: EditorState, from?: number | null, to?: number | null): Selection_3;
 
+export declare function getEditorContentDoc(schema: Schema, content: NodeJSON | string | HTMLElement | ProseMirrorNode): ProseMirrorNode;
+
+export declare function getEditorContentJSON(schema: Schema, content: NodeJSON | string | HTMLElement): NodeJSON;
+
+export declare function getEditorContentNode(schema: Schema, content: NodeJSON | string | HTMLElement | ProseMirrorNode): ProseMirrorNode;
+
+export declare function getEditorSelection(doc: ProseMirrorNode, selection: SelectionJSON | Selection_2 | 'start' | 'end'): Selection_2;
+
 /**
  * Returns a unique id in the current process that can be used in various places.
  *
@@ -1270,11 +1387,19 @@ export { getNodeType as getNodeType_alias_1 }
  */
 export declare function getNodeTypes(schema: Schema, types: string | NodeType | string[] | NodeType[]): NodeType[];
 
-export declare type GroupedEntries<T extends Record<string, any>> = {
+declare type GetStateFunction = () => EditorState | null | undefined;
+
+export declare function groupBy<K extends PropertyKey, T>(items: Iterable<T>, keySelector: (item: T) => K): Partial<Record<K, T[]>>;
+
+export declare function groupEntries<T extends Record<string, any>>(entries: ObjectEntries<T>[]): {
     [K in keyof T]?: T[K][];
 };
 
-export declare function groupEntries<T extends Record<string, any>>(entries: ObjectEntries<T>[]): GroupedEntries<T>;
+declare type HeadingExtension = Extension<{
+    Nodes: {
+        heading: Attrs;
+    };
+}>;
 
 /**
  * @internal
@@ -1377,6 +1502,8 @@ declare interface InsertNodeOptions {
 export { InsertNodeOptions }
 export { InsertNodeOptions as InsertNodeOptions_alias_1 }
 
+export declare function insertOutputSpecAttrs(dom: DOMOutputSpec, attrs: Array<[key: string, value: string]>): DOMOutputSpec;
+
 /**
  * Returns a command that inserts the given text.
  *
@@ -1394,7 +1521,9 @@ export declare type InsertTextOptions = {
 };
 
 /**
- * @internal
+ * Checks if the given object is a `AllSelection` instance.
+ *
+ * @public
  */
 declare function isAllSelection(sel: Selection_2): sel is AllSelection;
 export { isAllSelection }
@@ -1416,7 +1545,16 @@ declare function isAtBlockStart(state: EditorState, view?: EditorView): Resolved
 export { isAtBlockStart }
 export { isAtBlockStart as isAtBlockStart_alias_1 }
 
-export declare function isElement(value: unknown): value is Element;
+export declare function isElement(el: unknown): el is Element;
+
+/**
+ * Checks if the given object is a `Fragment` instance.
+ *
+ * @public
+ */
+declare function isFragment(fragment: unknown): fragment is Fragment;
+export { isFragment }
+export { isFragment as isFragment_alias_1 }
 
 /**
  * Check if the selection is in a code block.
@@ -1428,7 +1566,9 @@ export { isInCodeBlock }
 export { isInCodeBlock as isInCodeBlock_alias_1 }
 
 /**
- * @internal
+ * Checks if the given object is a `Mark` instance.
+ *
+ * @public
  */
 declare function isMark(mark: unknown): mark is Mark;
 export { isMark }
@@ -1455,21 +1595,46 @@ export { isMarkActive as isMarkActive_alias_1 }
 export declare function isNodeActive(state: EditorState, type: string | NodeType, attrs?: Attrs | null): boolean;
 
 /**
- * @internal
+ * Checks if the given object is a `NodeSelection` instance.
+ *
+ * @public
  */
 declare function isNodeSelection(sel: Selection_2): sel is NodeSelection;
 export { isNodeSelection }
 export { isNodeSelection as isNodeSelection_alias_1 }
 
-export declare function isNotNull<T>(value: T | null | undefined): value is T;
-
 /**
  * @internal
  */
+export declare function isNotNullish<T>(value: T | null | undefined | void): value is T;
+
+export declare function isObject(v: unknown): v is Record<string, unknown>;
+
+/**
+ * Checks if the given object is a `ProseMirrorNode` instance.
+ */
 declare function isProseMirrorNode(node: unknown): node is ProseMirrorNode;
 export { isProseMirrorNode }
 export { isProseMirrorNode as isProseMirrorNode_alias_1 }
 
+/**
+ * Checks if the given object is a `Selection` instance.
+ *
+ * @public
+ */
+declare function isSelection(sel: unknown): sel is Selection_2;
+export { isSelection }
+export { isSelection as isSelection_alias_1 }
+
+/**
+ * Checks if the given object is a `Slice` instance.
+ *
+ * @public
+ */
+declare function isSlice(slice: unknown): slice is Slice;
+export { isSlice }
+export { isSlice as isSlice_alias_1 }
+
 /**
  * Check if `subset` is a subset of `superset`.
  *
@@ -1478,12 +1643,20 @@ export { isProseMirrorNode as isProseMirrorNode_alias_1 }
 export declare function isSubset(subset: Record<string, unknown>, superset: Record<string, unknown>): boolean;
 
 /**
- * @internal
+ * Checks if the given object is a `TextSelection` instance.
+ *
+ * @public
  */
 declare function isTextSelection(sel: Selection_2): sel is TextSelection;
 export { isTextSelection }
 export { isTextSelection as isTextSelection_alias_1 }
 
+declare type ItalicExtension = Extension<{
+    Marks: {
+        italic: Attrs;
+    };
+}>;
+
 /**
  * Serialize a HTML element to a ProseMirror document JSON object.
  *
@@ -1556,6 +1729,16 @@ declare type KeyPressHandler = (view: EditorView, event: KeyboardEvent) => boole
 export { KeyPressHandler }
 export { KeyPressHandler as KeyPressHandler_alias_1 }
 
+declare interface LinkAttrs {
+    href: string;
+}
+
+declare type LinkExtension = Extension<{
+    Marks: {
+        link: LinkAttrs;
+    };
+}>;
+
 /**
  * A function for creating a mark with optional attributes and any number of
  * children.
@@ -1591,13 +1774,18 @@ declare interface MarkAttrOptions<MarkName extends string = string, AttrName ext
      */
     attr: AttrName;
     /**
-     * Returns the attribute key and value to be set on the DOM node.
+     * Returns the attribute key and value to be set on the HTML element.
+     *
+     * If the returned `key` is `"style"`, the value is a string of CSS properties and will
+     * be prepended to the existing `style` attribute on the DOM node.
+     *
+     * @param value - The value of the attribute of current ProseMirror node.
      */
-    toDOM?: (value: any) => [key: string, value: string] | null | void;
+    toDOM?: (value: AttrType) => [key: string, value: string] | null | undefined;
     /**
      * Parses the attribute value from the DOM.
      */
-    parseDOM?: (node: HTMLElement) => any;
+    parseDOM?: (node: HTMLElement) => AttrType;
 }
 export { MarkAttrOptions }
 export { MarkAttrOptions as MarkAttrOptions_alias_1 }
@@ -1643,6 +1831,12 @@ declare function maybeRun<T, R = T extends (...args: any[]) => void ? ReturnType
 export { maybeRun }
 export { maybeRun as maybeRun_alias_1 }
 
+export declare function mergeObjects<T extends object>(...objects: Array<Partial<T> | null | undefined>): Partial<T>;
+
+export declare function mergeSpecs(a: NodeSpec, b: NodeSpec): NodeSpec;
+
+export declare function mergeSpecs(a: MarkSpec, b: MarkSpec): MarkSpec;
+
 /**
  * A function that is called when the editor view is mounted.
  *
@@ -1697,16 +1891,18 @@ declare interface NodeAttrOptions<NodeName extends string = string, AttrName ext
      */
     splittable?: boolean;
     /**
-     * Returns the attribute key and value to be set on the DOM node.
+     * Returns the attribute key and value to be set on the HTML element.
      *
-     * If the `key` is `"style"`, the value is a string of CSS properties and will
+     * If the returned `key` is `"style"`, the value is a string of CSS properties and will
      * be prepended to the existing `style` attribute on the DOM node.
+     *
+     * @param value - The value of the attribute of current ProseMirror node.
      */
-    toDOM?: (value: any) => [key: string, value: string] | null | void;
+    toDOM?: (value: AttrType) => [key: string, value: string] | null | undefined;
     /**
      * Parses the attribute value from the DOM.
      */
-    parseDOM?: (node: HTMLElement) => any;
+    parseDOM?: (node: HTMLElement) => AttrType;
 }
 export { NodeAttrOptions }
 export { NodeAttrOptions as NodeAttrOptions_alias_1 }
@@ -1729,6 +1925,8 @@ export { NodeChild as NodeChild_alias_1 }
 
 /**
  * @public
+ *
+ * @deprecated
  */
 declare type NodeContent = ProseMirrorNode | ProseMirrorFragment | NodeContent[];
 export { NodeContent }
@@ -1768,7 +1966,10 @@ export { nodeFromJSON as nodeFromJSON_alias_1 }
  */
 declare interface NodeJSON {
     type: string;
-    marks?: Array<any>;
+    marks?: Array<{
+        type: string;
+        attrs?: Record<string, any>;
+    }>;
     text?: string;
     content?: NodeJSON[];
     attrs?: Record<string, any>;
@@ -2002,13 +2203,16 @@ declare interface RemoveNodeOptions {
      */
     type: string | NodeType;
     /**
-     * The document position to start searching node. By default it will be the anchor position of current selection.
+     * The document position to start searching node. By default it will be the
+     * anchor position of current selection.
      */
     pos?: number;
 }
 export { RemoveNodeOptions }
 export { RemoveNodeOptions as RemoveNodeOptions_alias_1 }
 
+export declare function removeUndefinedValues<T extends object>(obj: T): T;
+
 export declare const rootFacet: Facet<RootPayload, RootOutput>;
 
 export declare type RootOutput = {
@@ -2127,27 +2331,9 @@ export declare function setupEditorExtension<E extends Extension>(options: Edito
 export declare function setupTest(): {
     editor: TestEditor<Union<readonly [BaseCommandsExtension, PlainExtension, 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;
-    };
+    paragraph: Attrs;
     };
-    }>]>>;
+    }>, TextExtension, BoldExtension, ItalicExtension, LinkExtension, HeadingExtension, CodeBlockExtension]>>;
     m: ToMarkAction<SimplifyDeeper<    {
     bold: {
     readonly [x: string]: any;
@@ -2155,6 +2341,9 @@ export declare function setupTest(): {
     italic: {
     readonly [x: string]: any;
     };
+    link: {
+    href: string;
+    };
     }>>;
     n: {
         p: NodeAction<    {
@@ -2169,12 +2358,12 @@ export declare function setupTest(): {
         text: NodeAction<    {
         readonly [x: string]: any;
         }>;
-        codeBlock: NodeAction<    {
-        language: string;
-        }>;
         heading: NodeAction<    {
         readonly [x: string]: any;
         }>;
+        codeBlock: NodeAction<    {
+        language: string;
+        }>;
     };
 };
 
@@ -2318,9 +2507,11 @@ export declare type ToCommandCreators<T extends CommandTyping> = {
 /**
  * Returns a command that toggles the given mark with the given attributes.
  *
+ * @param options
+ *
  * @public
  */
-declare function toggleMark({ type, attrs }: ToggleMarkOptions): Command;
+declare function toggleMark({ type, attrs, removeWhenPresent, enterInlineAtoms, }: ToggleMarkOptions): Command;
 export { toggleMark }
 export { toggleMark as toggleMark_alias_1 }
 
@@ -2328,8 +2519,30 @@ export { toggleMark as toggleMark_alias_1 }
  * @public
  */
 declare interface ToggleMarkOptions {
+    /**
+     * The mark type to toggle.
+     */
     type: string | MarkType;
+    /**
+     * The optional attributes to set on the mark.
+     */
     attrs?: Attrs | null;
+    /**
+     * Controls whether, when part of the selected range has the mark
+     * already and part doesn't, the mark is removed (`true`) or added
+     * (`false`).
+     *
+     * @default false
+     */
+    removeWhenPresent?: boolean;
+    /**
+     * Whether the command should act on the content of inline nodes marked as
+     * [atoms](https://prosemirror.net/docs/ref/#model.NodeSpec.atom) that are
+     * completely covered by a selection range.
+     *
+     * @default true
+     */
+    enterInlineAtoms?: boolean;
 }
 export { ToggleMarkOptions }
 export { ToggleMarkOptions as ToggleMarkOptions_alias_1 }
@@ -2338,6 +2551,8 @@ export { ToggleMarkOptions as ToggleMarkOptions_alias_1 }
  * Returns a command that set the selected textblocks to the given node type
  * with the given attributes.
  *
+ * @param options
+ *
  * @public
  */
 declare function toggleNode({ type, attrs }: ToggleNodeOptions): Command;
@@ -2568,12 +2783,13 @@ export { withSkipCodeBlock }
 export { withSkipCodeBlock as withSkipCodeBlock_alias_1 }
 
 /**
- * Returns a command that wraps the selected textblock with the given node type
- * with the given attributes.
+ * Returns a command that wraps the selected textblock with the given node type.
+ *
+ * @param options
  *
  * @public
  */
-declare function wrap({ nodeType, attrs }: WrapOptions): Command;
+declare function wrap(options: WrapOptions): Command;
 export { wrap }
 export { wrap as wrap_alias_1 }
 
@@ -2581,12 +2797,26 @@ export { wrap as wrap_alias_1 }
  * @public
  */
 declare interface WrapOptions {
+    /**
+     * The node type to wrap the selected textblock with.
+     */
+    type: NodeType | string;
+    /**
+     * @deprecated Use `nodeSpec` instead.
+     */
     nodeType: NodeType;
+    /**
+     * Optional attributes to apply to the node.
+     */
     attrs?: Attrs | null;
 }
 export { WrapOptions }
 export { WrapOptions as WrapOptions_alias_1 }
 
+export declare function wrapOutputSpecAttrs<T extends ProseMirrorNode | Mark, Args extends readonly unknown[]>(toDOM: (node: T, ...args: Args) => DOMOutputSpec, options: AttrOptions[]): (node: T, ...args: Args) => DOMOutputSpec;
+
+export declare function wrapTagParseRuleAttrs(rule: TagParseRule, options: AttrOptions[]): TagParseRule;
+
 export declare function zip<T, P>(a: T[], b: P[]): [T, P][];
 
 export { }