@thomasfosterau/prosekit-utilities 0.0.0 → 0.1.0

package/dist/prosekit.d.ts

@@ -0,0 +1,3218 @@
+import { n as RegistryCache, y as RequiredAttribute } from "./index-DlgceBHe.js";
+import { f as NodeJSON, n as DocumentShape, u as DocumentJSON } from "./document-shape-CrKjPIEf.js";
+import * as Effect from "effect/Effect";
+import * as Schema$2 from "effect/Schema";
+import { Extension } from "prosekit/core";
+import { BoldExtension, defineBold } from "prosekit/extensions/bold";
+import { CodeExtension, defineCode } from "prosekit/extensions/code";
+import { ItalicExtension, defineItalic } from "prosekit/extensions/italic";
+import { LinkExtension, defineLink } from "prosekit/extensions/link";
+import { StrikeExtension, defineStrike } from "prosekit/extensions/strike";
+import { UnderlineExtension, defineUnderline } from "prosekit/extensions/underline";
+import { DocExtension, defineDoc } from "prosekit/extensions/doc";
+import { TextExtension, defineText } from "prosekit/extensions/text";
+import { ParagraphExtension, defineParagraph } from "prosekit/extensions/paragraph";
+import { HeadingExtension, defineHeading } from "prosekit/extensions/heading";
+import { ListExtension, defineList } from "prosekit/extensions/list";
+import { BlockquoteExtension, defineBlockquote } from "prosekit/extensions/blockquote";
+import { ImageExtension, defineImage } from "prosekit/extensions/image";
+import { HorizontalRuleExtension, defineHorizontalRule } from "prosekit/extensions/horizontal-rule";
+import { HardBreakExtension, defineHardBreak } from "prosekit/extensions/hard-break";
+import { TableExtension, defineTable } from "prosekit/extensions/table";
+import { CodeBlockExtension, defineCodeBlock } from "prosekit/extensions/code-block";
+import { Attrs, MarkType, NodeType, ProseMirrorNode, Schema } from "@prosekit/pm/model";
+import "@prosekit/pm/state";
+import "@prosekit/pm/view";
+import "@prosekit/pm/inputrules";
+/**
+ * The record `attributeOverlay()` consumes: node or mark name, then attribute
+ * name, then the Effect Schema for that attribute's value — optionally
+ * wrapped in `required(…)`.
+ */
+type AttributeOverrides = Readonly<Record<string, Readonly<Record<string, Schema$2.Top | RequiredAttribute>>>>;
+/**
+ * The overlay for ProseKit's stock nodes — the default when
+ * `defineDocumentSchema` is given no `attributes`.
+ *
+ * Every entry here is either a value type ProseMirror cannot express or a
+ * required-ness correction, and nothing else needs one: `link`'s
+ * `href`/`target`/`rel`, `list`'s `checked`/`collapsed` and the table cells'
+ * `colspan`/`rowspan` all derive correctly from ProseMirror's own `validate`
+ * string or default value.
+ *
+ * **Why `required(…)`.** ProseMirror's rule is that *any* attribute with a
+ * `default` — even one this overlay supplies a value type for — becomes an
+ * omissible key. But `heading.level`, `list.kind`, `image.src`/`width`/`height`
+ * and `codeBlock.language` are attributes a live editor always serialises:
+ * `Node.toJSON()` includes every attr, defaulted or not, so an
+ * editor-produced document always carries them. Leaving them omissible would
+ * let a machine-authored document skip the very value it was supposed to
+ * specify — a heading with no level, an image with no source — and still
+ * validate. `required(…)` closes that gap. `colwidth` is deliberately *not*
+ * wrapped: a cell that has never been resized genuinely has none.
+ */
+export declare const STANDARD_ATTRIBUTE_OVERRIDES: AttributeOverrides;
+/**
+ * The overlay entry for `defineMention()`, to merge over
+ * {@link STANDARD_ATTRIBUTE_OVERRIDES} when a grammar includes the mention
+ * node.
+ *
+ * Both attributes are `required(…)` for the reason above: a mention the editor
+ * produced always carries an id and a label, and a mention without an id
+ * resolves to nothing.
+ */
+export declare const MENTION_ATTRIBUTE_OVERRIDES: AttributeOverrides;
+/**
+ * Merges overlays left to right, per node and then per attribute; a later
+ * entry wins.
+ *
+ * ```ts
+ * const attributes = mergeAttributeOverrides(
+ *   STANDARD_ATTRIBUTE_OVERRIDES,
+ *   MENTION_ATTRIBUTE_OVERRIDES,
+ * );
+ * ```
+ *
+ * The merge is shallow *per node*: two overlays that both name `image` end up
+ * with the union of their attribute entries rather than one replacing the
+ * other, so an application can override `image.src` alone without restating
+ * `width` and `height`. Nothing is mutated — every call returns a new record.
+ */
+export declare const mergeAttributeOverrides: (...overrides: ReadonlyArray<AttributeOverrides>) => AttributeOverrides;
+declare const DocumentDecodeError_base: Schema$2.Class<DocumentDecodeError, Schema$2.TaggedStruct<"DocumentDecodeError", {
+  readonly document: Schema$2.String;
+  readonly issue: Schema$2.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A decode that failed, as a tagged error rather than a thrown
+ * `SchemaError` — for a caller that wants the failure in an `Effect` channel
+ * it can catch by tag.
+ *
+ * `document` is the shape's name, so one handler can tell a rejected title
+ * from a rejected body. `issue` is the underlying `SchemaError` carried
+ * through `Schema.Defect()`, which is JSON-encodable, so the error survives a
+ * wire hop to a client or a log sink.
+ */
+export declare class DocumentDecodeError extends /* @__PURE__ */ DocumentDecodeError_base {}
+/** How {@link defineDocumentSchema} builds a document schema. */
+interface DocumentSchemaOptions {
+  /**
+   * The grammar, as a factory. Called at most once, the first time a document
+   * is actually validated — see {@link DocumentSchema.schema}.
+   */
+  readonly extension: () => Extension;
+  /**
+   * The attribute overlay. Defaults to `STANDARD_ATTRIBUTE_OVERRIDES`; an
+   * application with opt-in nodes passes
+   * `mergeAttributeOverrides(STANDARD_ATTRIBUTE_OVERRIDES, …)`.
+   */
+  readonly attributes?: AttributeOverrides | undefined;
+  /**
+   * A `RegistryCache` to share with other document schemas built from
+   * overlapping extensions. Defaults to a cache private to this schema.
+   *
+   * Share one only between grammars whose mark sets match and whose same-named
+   * types are defined identically; otherwise the first schema forced decides
+   * the shared `text` node's marks for the others. See
+   * {@link defineDocumentSchema} for the failure this causes.
+   */
+  readonly registryCache?: RegistryCache | undefined;
+}
+/** One document surface's ProseKit half: the grammar, the wire schema and the guard. */
+interface DocumentSchema<Name extends string> {
+  /** The shape this schema was declared against, and which {@link install} upgrades. */
+  readonly shape: DocumentShape<Name>;
+  /** The grammar factory, as passed in. */
+  readonly extension: () => Extension;
+  /** The compiled ProseMirror schema, built on first use and cached (see `lazySchema`). */
+  readonly schema: () => Schema;
+  /** The derived wire schema: the envelope, with `shape.name` in place of ProseMirror's `doc`. */
+  readonly Document: Schema$2.Codec<DocumentJSON<Name>>;
+  /** A whole-document type guard over {@link Document}, with a defect net. */
+  readonly is: (value: unknown) => value is DocumentJSON<Name>;
+  /** {@link Document}'s decode in an `Effect`, failing with a {@link DocumentDecodeError}. */
+  readonly decode: (value: unknown) => Effect.Effect<DocumentJSON<Name>, DocumentDecodeError>;
+  /** Installs {@link is} as {@link shape}'s grammar guard, for the life of the isolate. */
+  readonly install: () => void;
+}
+/**
+ * Declares the ProseKit half of a document surface.
+ *
+ * ```ts
+ * const blockDocument = defineDocumentShape({ name: 'blockDocument' });   // root entry
+ * const cache = createRegistryCache();                                    // ./derive
+ *
+ * export const blockDocumentSchema = defineDocumentSchema(blockDocument, {
+ *   extension: () => defineBlockDocumentExtension(defineMention()),
+ *   attributes: mergeAttributeOverrides(STANDARD_ATTRIBUTE_OVERRIDES, MENTION_ATTRIBUTE_OVERRIDES),
+ *   registryCache: cache,
+ * });
+ * ```
+ *
+ * ## Lazy, all the way down
+ *
+ * Nothing here compiles or derives anything at declaration time.
+ * {@link DocumentSchema.schema} is a `lazySchema` thunk, and `Document` is
+ * wrapped in `Schema.suspend`, which defers its body until the schema is first
+ * used and memoises it thereafter. So importing the module that declares a
+ * document surface — as a model layer or a route module does — never pays for
+ * a ProseMirror compile or for building the derived Effect Schema graph unless
+ * a document is actually validated (PERF-CPU-001 in the source applications).
+ *
+ * ## Sharing derivation without coupling
+ *
+ * Two document schemas built from overlapping extensions — a block grammar and
+ * an inline grammar both composing `defineStandardMarks()` and `defineText()` —
+ * derive the same mark schemas and the same `text` node schema. Passing both
+ * the same `registryCache` means whichever is forced *first* builds that shared
+ * structure and the other reuses it.
+ *
+ * They nonetheless stay **independently lazy and independent failure
+ * domains**: validating one never forces compiling or deriving the other, and
+ * a defect in one's derivation cannot break the other. That is why this is not
+ * `deriveDocumentSchemas`, which batches N schemas in one eager call — it would
+ * force compiling every grammar up front and couple their failure domains, for
+ * exactly the same sharing benefit this gets without either cost.
+ *
+ * ## When two grammars may share a cache
+ *
+ * Only when their **mark sets match** and every node or mark type they both
+ * name is defined identically (the same spec and the same attribute overlay).
+ * The cache memoises derived schemas by type *name*, and an inline node's
+ * derived `marks` field is the union of every mark its grammar's textblocks
+ * admit. So two grammars that compose the same `text` node but different marks
+ * do not derive the same `text` schema, and whichever is forced first decides
+ * it for both.
+ *
+ * Concretely: a block grammar that adds `defineCitation()` and an inline
+ * grammar that does not must not share a cache. If they do, forcing the block
+ * schema first makes the inline schema accept a `citation` mark it never
+ * declared, and forcing the inline schema first makes the block schema reject
+ * its own `citation` marks. Neither order raises an error. Give such grammars
+ * separate caches (or none: the default is a private cache).
+ */
+export declare function defineDocumentSchema<Name extends string>(shape: DocumentShape<Name>, options: DocumentSchemaOptions): DocumentSchema<Name>;
+/**
+ * Installs every schema's grammar guard onto its shape — the persistence
+ * layer's one call.
+ *
+ * ```ts
+ * installDocumentGrammars(blockDocumentSchema, inlineDocumentSchema);
+ * ```
+ *
+ * Put it at module scope in the module a server runtime loads before handling
+ * a request and no browser bundle can reach (the one that declares the
+ * document columns). Installing is cheap — it stores a function reference and
+ * forces nothing — and every shape stays permissive until it happens, so a
+ * runtime that never installs under-checks rather than wrongly rejects.
+ */
+export declare const installDocumentGrammars: (...schemas: ReadonlyArray<DocumentSchema<string>>) => void;
+declare const HtmlRenderError_base: Schema$2.Class<HtmlRenderError, Schema$2.TaggedStruct<"HtmlRenderError", {
+  readonly reason: Schema$2.Literals<readonly ["dom-unavailable", "serialise"]>;
+  readonly cause: Schema$2.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A render that failed.
+ *
+ * `dom-unavailable` means no `Document` could be obtained: there is no global
+ * one and `linkedom` could not be imported (or a caller-supplied `document`
+ * thunk rejected). `serialise` means the document itself could not be turned
+ * into HTML — most often a node or mark the compiled schema does not know,
+ * which is what `htmlFromJSON` throws on. `cause` carries the original through
+ * `Schema.Defect()`, so the error is JSON-encodable and survives a log sink.
+ */
+export declare class HtmlRenderError extends /* @__PURE__ */ HtmlRenderError_base {}
+/**
+ * A copy of a document tree with every unsafe URL removed: `link` marks whose
+ * `href` fails {@link isSafeHref} are dropped from the node that carries them,
+ * and `image` children whose `src` fails it are dropped from their parent's
+ * content. Recursive, and non-mutating.
+ *
+ * Dropping the mark rather than the text keeps the prose — an unsafe link
+ * renders as plain words — while dropping the whole `image` node is the only
+ * option for a leaf whose entire content is its URL.
+ *
+ * Exported because the same pass belongs at any boundary that hands a document
+ * to something which will render it, not only to {@link createHtmlRenderer}.
+ */
+export declare function sanitiseDocument(node: NodeJSON): NodeJSON;
+/** How {@link createHtmlRenderer} builds a renderer. */
+interface HtmlRendererOptions {
+  /**
+   * The compiled ProseMirror schema to serialise against — pass a
+   * `DocumentSchema`'s own `schema` thunk, or a `lazySchema` one. Called per
+   * render, so it must be the caching kind.
+   */
+  readonly schema: () => Schema;
+  /**
+   * A pass over the rendered HTML string, given the same `Document` the render
+   * used. This is where a node that serialises to a placeholder element gets
+   * its real payload — a diagram block replacing its own `innerHTML` with a
+   * server-rendered SVG, say. Runs after serialisation and before the string
+   * is returned.
+   */
+  readonly postProcess?: ((html: string, document: Document) => string) | undefined;
+  /**
+   * Where the `Document` comes from. Defaults to capability detection: the
+   * global `document` if there is one, otherwise linkedom. Resolved once per
+   * renderer and cached.
+   */
+  readonly document?: (() => Promise<Document>) | undefined;
+}
+/** What {@link createHtmlRenderer} returns. */
+interface HtmlRenderer {
+  /** Renders a document to HTML, failing with an {@link HtmlRenderError}. */
+  readonly render: (doc: NodeJSON | DocumentJSON) => Effect.Effect<string, HtmlRenderError>;
+  /**
+   * {@link render} as a promise, rejecting with the {@link HtmlRenderError}
+   * itself — for a caller outside Effect, such as a component.
+   */
+  readonly renderPromise: (doc: NodeJSON | DocumentJSON) => Promise<string>;
+}
+/**
+ * Builds a renderer bound to one compiled schema.
+ *
+ * ```ts
+ * const renderer = createHtmlRenderer({ schema: blockDocumentSchema.schema });
+ * const html = await renderer.renderPromise(document);
+ * ```
+ *
+ * A renderer is cheap to create and holds the resolved `Document` promise, so
+ * create one per grammar at module scope rather than one per render.
+ *
+ * Every render sanitises first ({@link sanitiseDocument}), then rewrites the
+ * envelope's `type` back to `doc` — the surface name is a persistence rename,
+ * and a compiled schema's top node is always `doc`, so feeding the stored
+ * shape straight in throws `RangeError: Unknown node type`.
+ */
+export declare function createHtmlRenderer(options: HtmlRendererOptions): HtmlRenderer;
+/**
+ * Wraps an extension factory in a compile-once, cache-forever thunk.
+ *
+ * ```ts
+ * const schema = lazySchema(() => defineBlockDocumentExtension(defineMention()));
+ * schema() === schema(); // the same compiled instance, for the life of the isolate
+ * ```
+ *
+ * **Why lazy.** Compiling a ProseMirror schema builds the whole node and mark
+ * registry and the content-match automata for every content expression in it.
+ * It is expensive, and the result never changes at runtime. Doing it at module
+ * scope would charge that cost to every bundle that so much as names a
+ * document type; doing it per call charges it per use.
+ *
+ * **Why this matters more than it sounds (PERF-CPU-001 in the source
+ * applications).** Before this cache existed there, schema validation called
+ * `createEditor(...)` on every call — once per jsonb document column on every
+ * database row read, and once per server-side document render. An O(1) cost
+ * had become O(rows). Anything on a per-row or per-render path must go
+ * through a thunk like this one, never `createEditor` directly.
+ *
+ * The cache is an `Option` rather than a nullable so a schema is never
+ * recompiled because a falsy-looking value was cached, and the thunk is a
+ * closure rather than a module-scope slot so two grammars never share one.
+ */
+export declare function lazySchema(define: () => Extension): () => Schema;
+declare class OrderedMap<T = any> {
+  private constructor(content: Array<string | T>);
+  get(key: string): T | undefined;
+  update(key: string, value: T, newKey?: string): OrderedMap<T>;
+  remove(key: string): OrderedMap<T>;
+  addToStart(key: string, value: T): OrderedMap<T>;
+  addToEnd(key: string, value: T): OrderedMap<T>;
+  addBefore(place: string, key: string, value: T): OrderedMap<T>;
+  forEach(fn: (key: string, value: T) => any): void;
+  prepend(map: MapLike<T>): OrderedMap<T>;
+  append(map: MapLike<T>): OrderedMap<T>;
+  subtract(map: MapLike<T>): OrderedMap<T>;
+  toObject(): Record<string, T>;
+  readonly size: number;
+  static from<T>(map: MapLike<T>): OrderedMap<T>;
+}
+type MapLike<T = any> = Record<string, T> | OrderedMap<T>;
+/**
+A mark is a piece of information that can be attached to a node,
+such as it being emphasized, in code font, or a link. It has a
+type and optionally a set of attributes that provide further
+information (such as the target of the link). Marks are created
+through a `Schema`, which controls which types exist and which
+attributes they have.
+*/
+declare class Mark {
+  /**
+    The type of this mark.
+    */
+  readonly type: MarkType$1;
+  /**
+    The attributes associated with this mark.
+    */
+  readonly attrs: Attrs$1;
+  /**
+    Given a set of marks, create a new set which contains this one as
+    well, in the right position. If this mark is already in the set,
+    the set itself is returned. If any marks that are set to be
+    [exclusive](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) with this mark are present,
+    those are replaced by this one.
+    */
+  addToSet(set: readonly Mark[]): readonly Mark[];
+  /**
+    Remove this mark from the given set, returning a new set. If this
+    mark is not in the set, the set itself is returned.
+    */
+  removeFromSet(set: readonly Mark[]): readonly Mark[];
+  /**
+    Test whether this mark is in the given set of marks.
+    */
+  isInSet(set: readonly Mark[]): boolean;
+  /**
+    Test whether this mark has the same type and attributes as
+    another mark.
+    */
+  eq(other: Mark): boolean;
+  /**
+    Convert this mark to a JSON-serializeable representation.
+    */
+  toJSON(): any;
+  /**
+    Deserialize a mark from JSON.
+    */
+  static fromJSON(schema: Schema$1, json: any): Mark;
+  /**
+    Test whether two sets of marks are identical.
+    */
+  static sameSet(a: readonly Mark[], b: readonly Mark[]): boolean;
+  /**
+    Create a properly sorted mark set from null, a single mark, or an
+    unsorted array of marks.
+    */
+  static setFrom(marks?: Mark | readonly Mark[] | null): readonly Mark[];
+  /**
+    The empty set of marks.
+    */
+  static none: readonly Mark[];
+}
+/**
+A description of a DOM structure. Can be either a DOM element, a
+`{dom, contentDOM}` object, or an array.
+
+An array describes a DOM element. The first value in the array
+should be a string—the name of the DOM element, optionally
+prefixed by a namespace URL and a space. If the second element is
+plain object, it is interpreted as a set of attributes for the
+element. Any elements after that (including the 2nd if it's not an
+attribute object) are interpreted as children of the DOM elements,
+and must either be valid `DOMOutputSpec` values, strings (for text
+nodes), or the number zero.
+
+The number zero (pronounced “hole”) is used to indicate the place
+where a node's child nodes should be inserted. If it occurs in an
+output spec, it should be the only child element in its parent
+node.
+*/
+type DOMOutputSpec = HTMLElement | {
+  dom: HTMLElement;
+  contentDOM?: HTMLElement;
+} | readonly [string, ...any[]];
+/**
+You can [_resolve_](https://prosemirror.net/docs/ref/#model.Node.resolve) a position to get more
+information about it. Objects of this class represent such a
+resolved position, providing various pieces of context
+information, and some helper methods.
+
+Throughout this interface, methods that take an optional `depth`
+parameter will interpret undefined as `this.depth` and negative
+numbers as `this.depth + value`.
+*/
+declare class ResolvedPos {
+  /**
+    The position that was resolved.
+    */
+  readonly pos: number;
+  /**
+    The offset this position has into its parent node.
+    */
+  readonly parentOffset: number;
+  /**
+    The number of levels the parent node is from the root. If this
+    position points directly into the root node, it is 0. If it
+    points into a top-level paragraph, 1, and so on.
+    */
+  depth: number;
+  /**
+    The parent node that the position points into. Note that even if
+    a position points into a text node, that node is not considered
+    the parent—text nodes are ‘flat’ in this model, and have no content.
+    */
+  get parent(): Node;
+  /**
+    The root node in which the position was resolved.
+    */
+  get doc(): Node;
+  /**
+    The ancestor node at the given level. `p.node(p.depth)` is the
+    same as `p.parent`.
+    */
+  node(depth?: number | null): Node;
+  /**
+    The index into the ancestor at the given level. If this points
+    at the 3rd node in the 2nd paragraph on the top level, for
+    example, `p.index(0)` is 1 and `p.index(1)` is 2.
+    */
+  index(depth?: number | null): number;
+  /**
+    The index pointing after this position into the ancestor at the
+    given level.
+    */
+  indexAfter(depth?: number | null): number;
+  /**
+    The (absolute) position at the start of the node at the given
+    level.
+    */
+  start(depth?: number | null): number;
+  /**
+    The (absolute) position at the end of the node at the given
+    level.
+    */
+  end(depth?: number | null): number;
+  /**
+    The (absolute) position directly before the wrapping node at the
+    given level, or, when `depth` is `this.depth + 1`, the original
+    position.
+    */
+  before(depth?: number | null): number;
+  /**
+    The (absolute) position directly after the wrapping node at the
+    given level, or the original position when `depth` is `this.depth + 1`.
+    */
+  after(depth?: number | null): number;
+  /**
+    When this position points into a text node, this returns the
+    distance between the position and the start of the text node.
+    Will be zero for positions that point between nodes.
+    */
+  get textOffset(): number;
+  /**
+    Get the node directly after the position, if any. If the position
+    points into a text node, only the part of that node after the
+    position is returned.
+    */
+  get nodeAfter(): Node | null;
+  /**
+    Get the node directly before the position, if any. If the
+    position points into a text node, only the part of that node
+    before the position is returned.
+    */
+  get nodeBefore(): Node | null;
+  /**
+    Get the position at the given index in the parent node at the
+    given depth (which defaults to `this.depth`).
+    */
+  posAtIndex(index: number, depth?: number | null): number;
+  /**
+    Get the marks at this position, factoring in the surrounding
+    marks' [`inclusive`](https://prosemirror.net/docs/ref/#model.MarkSpec.inclusive) property. If the
+    position is at the start of a non-empty node, the marks of the
+    node after it (if any) are returned.
+    */
+  marks(): readonly Mark[];
+  /**
+    Get the marks after the current position, if any, except those
+    that are non-inclusive and not present at position `$end`. This
+    is mostly useful for getting the set of marks to preserve after a
+    deletion. Will return `null` if this position is at the end of
+    its parent node or its parent node isn't a textblock (in which
+    case no marks should be preserved).
+    */
+  marksAcross($end: ResolvedPos): readonly Mark[] | null;
+  /**
+    The depth up to which this position and the given (non-resolved)
+    position share the same parent nodes.
+    */
+  sharedDepth(pos: number): number;
+  /**
+    Returns a range based on the place where this position and the
+    given position diverge around block content. If both point into
+    the same textblock, for example, a range around that textblock
+    will be returned. If they point into different blocks, the range
+    around those blocks in their shared ancestor is returned. You can
+    pass in an optional predicate that will be called with a parent
+    node to see if a range into that parent is acceptable.
+    */
+  blockRange(other?: ResolvedPos, pred?: (node: Node) => boolean): NodeRange | null;
+  /**
+    Query whether the given position shares the same parent node.
+    */
+  sameParent(other: ResolvedPos): boolean;
+  /**
+    Return the greater of this and the given position.
+    */
+  max(other: ResolvedPos): ResolvedPos;
+  /**
+    Return the smaller of this and the given position.
+    */
+  min(other: ResolvedPos): ResolvedPos;
+}
+/**
+Represents a flat range of content, i.e. one that starts and
+ends in the same node.
+*/
+declare class NodeRange {
+  /**
+    A resolved position along the start of the content. May have a
+    `depth` greater than this object's `depth` property, since
+    these are the positions that were used to compute the range,
+    not re-resolved positions directly at its boundaries.
+    */
+  readonly $from: ResolvedPos;
+  /**
+    A position along the end of the content. See
+    caveat for [`$from`](https://prosemirror.net/docs/ref/#model.NodeRange.$from).
+    */
+  readonly $to: ResolvedPos;
+  /**
+    The depth of the node that this range points into.
+    */
+  readonly depth: number;
+  /**
+    Construct a node range. `$from` and `$to` should point into the
+    same node until at least the given `depth`, since a node range
+    denotes an adjacent set of nodes in a single parent node.
+    */
+  constructor(
+  /**
+    A resolved position along the start of the content. May have a
+    `depth` greater than this object's `depth` property, since
+    these are the positions that were used to compute the range,
+    not re-resolved positions directly at its boundaries.
+    */
+  $from: ResolvedPos,
+  /**
+    A position along the end of the content. See
+    caveat for [`$from`](https://prosemirror.net/docs/ref/#model.NodeRange.$from).
+    */
+  $to: ResolvedPos,
+  /**
+    The depth of the node that this range points into.
+    */
+  depth: number);
+  /**
+    The position at the start of the range.
+    */
+  get start(): number;
+  /**
+    The position at the end of the range.
+    */
+  get end(): number;
+  /**
+    The parent node that the range points into.
+    */
+  get parent(): Node;
+  /**
+    The start index of the range in the parent node.
+    */
+  get startIndex(): number;
+  /**
+    The end index of the range in the parent node.
+    */
+  get endIndex(): number;
+}
+/**
+A slice represents a piece cut out of a larger document. It
+stores not only a fragment, but also the depth up to which nodes on
+both side are ‘open’ (cut through).
+*/
+declare class Slice {
+  /**
+    The slice's content.
+    */
+  readonly content: Fragment;
+  /**
+    The open depth at the start of the fragment.
+    */
+  readonly openStart: number;
+  /**
+    The open depth at the end.
+    */
+  readonly openEnd: number;
+  /**
+    Create a slice. When specifying a non-zero open depth, you must
+    make sure that there are nodes of at least that depth at the
+    appropriate side of the fragment—i.e. if the fragment is an
+    empty paragraph node, `openStart` and `openEnd` can't be greater
+    than 1.
+    
+    It is not necessary for the content of open nodes to conform to
+    the schema's content constraints, though it should be a valid
+    start/end/middle for such a node, depending on which sides are
+    open.
+    */
+  constructor(
+  /**
+    The slice's content.
+    */
+  content: Fragment,
+  /**
+    The open depth at the start of the fragment.
+    */
+  openStart: number,
+  /**
+    The open depth at the end.
+    */
+  openEnd: number);
+  /**
+    The size this slice would add when inserted into a document.
+    */
+  get size(): number;
+  /**
+    Tests whether this slice is equal to another slice.
+    */
+  eq(other: Slice): boolean;
+  /**
+    Convert a slice to a JSON-serializable representation.
+    */
+  toJSON(): any;
+  /**
+    Deserialize a slice from its JSON representation.
+    */
+  static fromJSON(schema: Schema$1, json: any): Slice;
+  /**
+    Create a slice from a fragment by taking the maximum possible
+    open value on both side of the fragment.
+    */
+  static maxOpen(fragment: Fragment, openIsolating?: boolean): Slice;
+  /**
+    The empty slice.
+    */
+  static empty: Slice;
+}
+type DOMNode = InstanceType<typeof window.Node>;
+/**
+Fields that may be present in both [tag](https://prosemirror.net/docs/ref/#model.TagParseRule) and
+[style](https://prosemirror.net/docs/ref/#model.StyleParseRule) parse rules.
+*/
+interface GenericParseRule {
+  /**
+    Can be used to change the order in which the parse rules in a
+    schema are tried. Those with higher priority come first. Rules
+    without a priority are counted as having priority 50. This
+    property is only meaningful in a schema—when directly
+    constructing a parser, the order of the rule array is used.
+    */
+  priority?: number;
+  /**
+    By default, when a rule matches an element or style, no further
+    rules get a chance to match it. By setting this to `false`, you
+    indicate that even when this rule matches, other rules that come
+    after it should also run.
+    */
+  consuming?: boolean;
+  /**
+    When given, restricts this rule to only match when the current
+    context—the parent nodes into which the content is being
+    parsed—matches this expression. Should contain one or more node
+    names or node group names followed by single or double slashes.
+    For example `"paragraph/"` means the rule only matches when the
+    parent node is a paragraph, `"blockquote/paragraph/"` restricts
+    it to be in a paragraph that is inside a blockquote, and
+    `"section//"` matches any position inside a section—a double
+    slash matches any sequence of ancestor nodes. To allow multiple
+    different contexts, they can be separated by a pipe (`|`)
+    character, as in `"blockquote/|list_item/"`.
+    */
+  context?: string;
+  /**
+    The name of the mark type to wrap the matched content in.
+    */
+  mark?: string;
+  /**
+    When true, ignore content that matches this rule. Any `<head>`,
+    `<noscript>`, `<script>`, `<object>`, `<style>`, or `<title>`
+    tags encountered are automatically ignored when no rules match
+    them..
+    */
+  ignore?: boolean;
+  /**
+    When true, finding an element that matches this rule will close
+    the current node.
+    */
+  closeParent?: boolean;
+  /**
+    When true, ignore the node that matches this rule, but do parse
+    its content.
+    */
+  skip?: boolean;
+  /**
+    Attributes for the node or mark created by this rule. When
+    `getAttrs` is provided, it takes precedence.
+    */
+  attrs?: Attrs$1;
+}
+/**
+Parse rule targeting a DOM element.
+*/
+interface TagParseRule extends GenericParseRule {
+  /**
+    A CSS selector describing the kind of DOM elements to match.
+    */
+  tag: string;
+  /**
+    The namespace to match. Nodes are only matched when the
+    namespace matches or this property is null.
+    */
+  namespace?: string;
+  /**
+    The name of the node type to create when this rule matches. Each
+    rule should have either a `node`, `mark`, or `ignore` property
+    (except when it appears in a [node](https://prosemirror.net/docs/ref/#model.NodeSpec.parseDOM) or
+    [mark spec](https://prosemirror.net/docs/ref/#model.MarkSpec.parseDOM), in which case the `node`
+    or `mark` property will be derived from its position).
+    */
+  node?: string;
+  /**
+    A function used to compute the attributes for the node or mark
+    created by this rule. Can also be used to describe further
+    conditions the DOM element or style must match. When it returns
+    `false`, the rule won't match. When it returns null or undefined,
+    that is interpreted as an empty/default set of attributes.
+    */
+  getAttrs?: (node: HTMLElement) => Attrs$1 | false | null;
+  /**
+    For rules that produce non-leaf nodes, by default the content of
+    the DOM element is parsed as content of the node. If the child
+    nodes are in a descendent node, this may be a CSS selector
+    string that the parser must use to find the actual content
+    element, or a function that returns the actual content element
+    to the parser.
+    */
+  contentElement?: string | HTMLElement | ((node: HTMLElement) => HTMLElement);
+  /**
+    Can be used to override the content of a matched node. When
+    present, instead of parsing the node's child nodes, the result of
+    this function is used.
+    */
+  getContent?: (node: DOMNode, schema: Schema$1) => Fragment;
+  /**
+    Controls whether whitespace should be preserved when parsing the
+    content inside the matched element. `false` means whitespace may
+    be collapsed, `true` means that whitespace should be preserved
+    but newlines normalized to spaces, and `"full"` means that
+    newlines should also be preserved.
+    */
+  preserveWhitespace?: boolean | "full";
+}
+/**
+A parse rule targeting a style property.
+*/
+interface StyleParseRule extends GenericParseRule {
+  /**
+    A CSS property name to match. This rule will match inline styles
+    that list that property. May also have the form
+    `"property=value"`, in which case the rule only matches if the
+    property's value exactly matches the given value. (For more
+    complicated filters, use [`getAttrs`](https://prosemirror.net/docs/ref/#model.StyleParseRule.getAttrs)
+    and return false to indicate that the match failed.) Rules
+    matching styles may only produce [marks](https://prosemirror.net/docs/ref/#model.GenericParseRule.mark),
+    not nodes.
+    */
+  style: string;
+  /**
+    Given to make TS see ParseRule as a tagged union @hide
+    */
+  tag?: undefined;
+  /**
+    Style rules can remove marks from the set of active marks.
+    */
+  clearMark?: (mark: Mark) => boolean;
+  /**
+    A function used to compute the attributes for the node or mark
+    created by this rule. Called with the style's value.
+    */
+  getAttrs?: (node: string) => Attrs$1 | false | null;
+}
+/**
+A value that describes how to parse a given DOM node or inline
+style as a ProseMirror node or mark.
+*/
+type ParseRule = TagParseRule | StyleParseRule;
+/**
+An object holding the attributes of a node.
+*/
+type Attrs$1 = {
+  readonly [attr: string]: any;
+};
+/**
+Node types are objects allocated once per `Schema` and used to
+[tag](https://prosemirror.net/docs/ref/#model.Node.type) `Node` instances. They contain information
+about the node type, such as its name and what kind of node it
+represents.
+*/
+declare class NodeType$1 {
+  /**
+    The name the node type has in this schema.
+    */
+  readonly name: string;
+  /**
+    A link back to the `Schema` the node type belongs to.
+    */
+  readonly schema: Schema$1;
+  /**
+    The spec that this type is based on
+    */
+  readonly spec: NodeSpec;
+  /**
+    True if this node type has inline content.
+    */
+  inlineContent: boolean;
+  /**
+    True if this is a block type
+    */
+  isBlock: boolean;
+  /**
+    True if this is the text node type.
+    */
+  isText: boolean;
+  /**
+    True if this is an inline type.
+    */
+  get isInline(): boolean;
+  /**
+    True if this is a textblock type, a block that contains inline
+    content.
+    */
+  get isTextblock(): boolean;
+  /**
+    True for node types that allow no content.
+    */
+  get isLeaf(): boolean;
+  /**
+    True when this node is an atom, i.e. when it does not have
+    directly editable content.
+    */
+  get isAtom(): boolean;
+  /**
+    Return true when this node type is part of the given
+    [group](https://prosemirror.net/docs/ref/#model.NodeSpec.group).
+    */
+  isInGroup(group: string): boolean;
+  /**
+    The starting match of the node type's content expression.
+    */
+  contentMatch: ContentMatch;
+  /**
+    The set of marks allowed in this node. `null` means all marks
+    are allowed.
+    */
+  markSet: readonly MarkType$1[] | null;
+  /**
+    The node type's [whitespace](https://prosemirror.net/docs/ref/#model.NodeSpec.whitespace) option.
+    */
+  get whitespace(): "pre" | "normal";
+  /**
+    Tells you whether this node type has any required attributes.
+    */
+  hasRequiredAttrs(): boolean;
+  /**
+    Indicates whether this node allows some of the same content as
+    the given node type.
+    */
+  compatibleContent(other: NodeType$1): boolean;
+  /**
+    Create a `Node` of this type. The given attributes are
+    checked and defaulted (you can pass `null` to use the type's
+    defaults entirely, if no required attributes exist). `content`
+    may be a `Fragment`, a node, an array of nodes, or
+    `null`. Similarly `marks` may be `null` to default to the empty
+    set of marks.
+    */
+  create(attrs?: Attrs$1 | null, content?: Fragment | Node | readonly Node[] | null, marks?: readonly Mark[]): Node;
+  /**
+    Like [`create`](https://prosemirror.net/docs/ref/#model.NodeType.create), but check the given content
+    against the node type's content restrictions, and throw an error
+    if it doesn't match.
+    */
+  createChecked(attrs?: Attrs$1 | null, content?: Fragment | Node | readonly Node[] | null, marks?: readonly Mark[]): Node;
+  /**
+    Like [`create`](https://prosemirror.net/docs/ref/#model.NodeType.create), but see if it is
+    necessary to add nodes to the start or end of the given fragment
+    to make it fit the node. If no fitting wrapping can be found,
+    return null. Note that, due to the fact that required nodes can
+    always be created, this will always succeed if you pass null or
+    `Fragment.empty` as content.
+    */
+  createAndFill(attrs?: Attrs$1 | null, content?: Fragment | Node | readonly Node[] | null, marks?: readonly Mark[]): Node | null;
+  /**
+    Returns true if the given fragment is valid content for this node
+    type.
+    */
+  validContent(content: Fragment): boolean;
+  /**
+    Check whether the given mark type is allowed in this node.
+    */
+  allowsMarkType(markType: MarkType$1): boolean;
+  /**
+    Test whether the given set of marks are allowed in this node.
+    */
+  allowsMarks(marks: readonly Mark[]): boolean;
+  /**
+    Removes the marks that are not allowed in this node from the given set.
+    */
+  allowedMarks(marks: readonly Mark[]): readonly Mark[];
+}
+/**
+Like nodes, marks (which are associated with nodes to signify
+things like emphasis or being part of a link) are
+[tagged](https://prosemirror.net/docs/ref/#model.Mark.type) with type objects, which are
+instantiated once per `Schema`.
+*/
+declare class MarkType$1 {
+  /**
+    The name of the mark type.
+    */
+  readonly name: string;
+  /**
+    The schema that this mark type instance is part of.
+    */
+  readonly schema: Schema$1;
+  /**
+    The spec on which the type is based.
+    */
+  readonly spec: MarkSpec;
+  /**
+    Create a mark of this type. `attrs` may be `null` or an object
+    containing only some of the mark's attributes. The others, if
+    they have defaults, will be added.
+    */
+  create(attrs?: Attrs$1 | null): Mark;
+  /**
+    When there is a mark of this type in the given set, a new set
+    without it is returned. Otherwise, the input set is returned.
+    */
+  removeFromSet(set: readonly Mark[]): readonly Mark[];
+  /**
+    Tests whether there is a mark of this type in the given set.
+    */
+  isInSet(set: readonly Mark[]): Mark | undefined;
+  /**
+    Queries whether a given mark type is
+    [excluded](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) by this one.
+    */
+  excludes(other: MarkType$1): boolean;
+}
+/**
+An object describing a schema, as passed to the [`Schema`](https://prosemirror.net/docs/ref/#model.Schema)
+constructor.
+*/
+interface SchemaSpec<Nodes extends string = any, Marks extends string = any> {
+  /**
+    The node types in this schema. Maps names to
+    [`NodeSpec`](https://prosemirror.net/docs/ref/#model.NodeSpec) objects that describe the node type
+    associated with that name. Their order is significant—it
+    determines which [parse rules](https://prosemirror.net/docs/ref/#model.NodeSpec.parseDOM) take
+    precedence by default, and which nodes come first in a given
+    [group](https://prosemirror.net/docs/ref/#model.NodeSpec.group).
+    */
+  nodes: { [name in Nodes]: NodeSpec; } | OrderedMap<NodeSpec>;
+  /**
+    The mark types that exist in this schema. The order in which they
+    are provided determines the order in which [mark
+    sets](https://prosemirror.net/docs/ref/#model.Mark.addToSet) are sorted and in which [parse
+    rules](https://prosemirror.net/docs/ref/#model.MarkSpec.parseDOM) are tried.
+    */
+  marks?: { [name in Marks]: MarkSpec; } | OrderedMap<MarkSpec>;
+  /**
+    The name of the default top-level node for the schema. Defaults
+    to `"doc"`.
+    */
+  topNode?: string;
+}
+/**
+A description of a node type, used when defining a schema.
+*/
+interface NodeSpec {
+  /**
+    The content expression for this node, as described in the [schema
+    guide](https://prosemirror.net/docs/guide/#schema.content_expressions). When not given,
+    the node does not allow any content.
+    */
+  content?: string;
+  /**
+    The marks that are allowed inside of this node. May be a
+    space-separated string referring to mark names or groups, `"_"`
+    to explicitly allow all marks, or `""` to disallow marks. When
+    not given, nodes with inline content default to allowing all
+    marks, other nodes default to not allowing marks.
+    */
+  marks?: string;
+  /**
+    The group or space-separated groups to which this node belongs,
+    which can be referred to in the content expressions for the
+    schema.
+    */
+  group?: string;
+  /**
+    Should be set to true for inline nodes. (Implied for text nodes.)
+    */
+  inline?: boolean;
+  /**
+    Can be set to true to indicate that, though this isn't a [leaf
+    node](https://prosemirror.net/docs/ref/#model.NodeType.isLeaf), it doesn't have directly editable
+    content and should be treated as a single unit in the view.
+    */
+  atom?: boolean;
+  /**
+    The attributes that nodes of this type get.
+    */
+  attrs?: {
+    [name: string]: AttributeSpec$1;
+  };
+  /**
+    Controls whether nodes of this type can be selected as a [node
+    selection](https://prosemirror.net/docs/ref/#state.NodeSelection). Defaults to true for non-text
+    nodes.
+    */
+  selectable?: boolean;
+  /**
+    Determines whether nodes of this type can be dragged without
+    being selected. Defaults to false.
+    */
+  draggable?: boolean;
+  /**
+    Can be used to indicate that this node contains code, which
+    causes some commands to behave differently.
+    */
+  code?: boolean;
+  /**
+    Controls way whitespace in this a node is parsed. The default is
+    `"normal"`, which causes the [DOM parser](https://prosemirror.net/docs/ref/#model.DOMParser) to
+    collapse whitespace in normal mode, and normalize it (replacing
+    newlines and such with spaces) otherwise. `"pre"` causes the
+    parser to preserve spaces inside the node. When this option isn't
+    given, but [`code`](https://prosemirror.net/docs/ref/#model.NodeSpec.code) is true, `whitespace`
+    will default to `"pre"`. Note that this option doesn't influence
+    the way the node is rendered—that should be handled by `toDOM`
+    and/or styling.
+    */
+  whitespace?: "pre" | "normal";
+  /**
+    Determines whether this node is considered an important parent
+    node during replace operations (such as paste). Non-defining (the
+    default) nodes get dropped when their entire content is replaced,
+    whereas defining nodes persist and wrap the inserted content.
+    */
+  definingAsContext?: boolean;
+  /**
+    In inserted content the defining parents of the content are
+    preserved when possible. Typically, non-default-paragraph
+    textblock types, and possibly list items, are marked as defining.
+    */
+  definingForContent?: boolean;
+  /**
+    When enabled, enables both
+    [`definingAsContext`](https://prosemirror.net/docs/ref/#model.NodeSpec.definingAsContext) and
+    [`definingForContent`](https://prosemirror.net/docs/ref/#model.NodeSpec.definingForContent).
+    */
+  defining?: boolean;
+  /**
+    When enabled (default is false), the sides of nodes of this type
+    count as boundaries that regular editing operations, like
+    backspacing or lifting, won't cross. An example of a node that
+    should probably have this enabled is a table cell.
+    */
+  isolating?: boolean;
+  /**
+    Defines the default way a node of this type should be serialized
+    to DOM/HTML (as used by
+    [`DOMSerializer.fromSchema`](https://prosemirror.net/docs/ref/#model.DOMSerializer^fromSchema)).
+    Should return a DOM node or an [array
+    structure](https://prosemirror.net/docs/ref/#model.DOMOutputSpec) that describes one, with an
+    optional number zero (“hole”) in it to indicate where the node's
+    content should be inserted.
+    
+    For text nodes, the default is to create a text DOM node. Though
+    it is possible to create a serializer where text is rendered
+    differently, this is not supported inside the editor, so you
+    shouldn't override that in your text node spec.
+    */
+  toDOM?: (node: Node) => DOMOutputSpec;
+  /**
+    Associates DOM parser information with this node, which can be
+    used by [`DOMParser.fromSchema`](https://prosemirror.net/docs/ref/#model.DOMParser^fromSchema) to
+    automatically derive a parser. The `node` field in the rules is
+    implied (the name of this node will be filled in automatically).
+    If you supply your own parser, you do not need to also specify
+    parsing rules in your schema.
+    */
+  parseDOM?: readonly TagParseRule[];
+  /**
+    Defines the default way a node of this type should be serialized
+    to a string representation for debugging (e.g. in error messages).
+    */
+  toDebugString?: (node: Node) => string;
+  /**
+    Defines the default way a [leaf node](https://prosemirror.net/docs/ref/#model.NodeType.isLeaf) of
+    this type should be serialized to a string (as used by
+    [`Node.textBetween`](https://prosemirror.net/docs/ref/#model.Node.textBetween) and
+    [`Node.textContent`](https://prosemirror.net/docs/ref/#model.Node.textContent)).
+    */
+  leafText?: (node: Node) => string;
+  /**
+    A single inline node in a schema can be set to be a linebreak
+    equivalent. When converting between block types that support the
+    node and block types that don't but have
+    [`whitespace`](https://prosemirror.net/docs/ref/#model.NodeSpec.whitespace) set to `"pre"`,
+    [`setBlockType`](https://prosemirror.net/docs/ref/#transform.Transform.setBlockType) will convert
+    between newline characters to or from linebreak nodes as
+    appropriate.
+    */
+  linebreakReplacement?: boolean;
+  /**
+    Node specs may include arbitrary properties that can be read by
+    other code via [`NodeType.spec`](https://prosemirror.net/docs/ref/#model.NodeType.spec).
+    */
+  [key: string]: any;
+}
+/**
+Used to define marks when creating a schema.
+*/
+interface MarkSpec {
+  /**
+    The attributes that marks of this type get.
+    */
+  attrs?: {
+    [name: string]: AttributeSpec$1;
+  };
+  /**
+    Whether this mark should be active when the cursor is positioned
+    at its end (or at its start when that is also the start of the
+    parent node). Defaults to true.
+    */
+  inclusive?: boolean;
+  /**
+    Determines which other marks this mark can coexist with. Should
+    be a space-separated strings naming other marks or groups of marks.
+    When a mark is [added](https://prosemirror.net/docs/ref/#model.Mark.addToSet) to a set, all marks
+    that it excludes are removed in the process. If the set contains
+    any mark that excludes the new mark but is not, itself, excluded
+    by the new mark, the mark can not be added an the set. You can
+    use the value `"_"` to indicate that the mark excludes all
+    marks in the schema.
+    
+    Defaults to only being exclusive with marks of the same type. You
+    can set it to an empty string (or any string not containing the
+    mark's own name) to allow multiple marks of a given type to
+    coexist (as long as they have different attributes).
+    */
+  excludes?: string;
+  /**
+    The group or space-separated groups to which this mark belongs.
+    */
+  group?: string;
+  /**
+    Determines whether marks of this type can span multiple adjacent
+    nodes when serialized to DOM/HTML. Defaults to true.
+    */
+  spanning?: boolean;
+  /**
+    Marks the content of this span as being code, which causes some
+    commands and extensions to treat it differently.
+    */
+  code?: boolean;
+  /**
+    Defines the default way marks of this type should be serialized
+    to DOM/HTML. When the resulting spec contains a hole, that is
+    where the marked content is placed. Otherwise, it is appended to
+    the top node.
+    */
+  toDOM?: (mark: Mark, inline: boolean) => DOMOutputSpec;
+  /**
+    Associates DOM parser information with this mark (see the
+    corresponding [node spec field](https://prosemirror.net/docs/ref/#model.NodeSpec.parseDOM)). The
+    `mark` field in the rules is implied.
+    */
+  parseDOM?: readonly ParseRule[];
+  /**
+    Mark specs can include additional properties that can be
+    inspected through [`MarkType.spec`](https://prosemirror.net/docs/ref/#model.MarkType.spec) when
+    working with the mark.
+    */
+  [key: string]: any;
+}
+/**
+Used to [define](https://prosemirror.net/docs/ref/#model.NodeSpec.attrs) attributes on nodes or
+marks.
+*/
+interface AttributeSpec$1 {
+  /**
+    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?: any;
+  /**
+    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: any) => void);
+}
+/**
+A document schema. Holds [node](https://prosemirror.net/docs/ref/#model.NodeType) and [mark
+type](https://prosemirror.net/docs/ref/#model.MarkType) objects for the nodes and marks that may
+occur in conforming documents, and provides functionality for
+creating and deserializing such documents.
+
+When given, the type parameters provide the names of the nodes and
+marks in this schema.
+*/
+declare class Schema$1<Nodes extends string = any, Marks extends string = any> {
+  /**
+    The [spec](https://prosemirror.net/docs/ref/#model.SchemaSpec) on which the schema is based,
+    with the added guarantee that its `nodes` and `marks`
+    properties are
+    [`OrderedMap`](https://code.haverbeke.berlin/marijn/orderedmap) instances
+    (not raw objects).
+    */
+  spec: {
+    nodes: OrderedMap<NodeSpec>;
+    marks: OrderedMap<MarkSpec>;
+    topNode?: string;
+  };
+  /**
+    An object mapping the schema's node names to node type objects.
+    */
+  nodes: { readonly [name in Nodes]: NodeType$1; } & {
+    readonly [key: string]: NodeType$1;
+  };
+  /**
+    A map from mark names to mark type objects.
+    */
+  marks: { readonly [name in Marks]: MarkType$1; } & {
+    readonly [key: string]: MarkType$1;
+  };
+  /**
+    The [linebreak
+    replacement](https://prosemirror.net/docs/ref/#model.NodeSpec.linebreakReplacement) node defined
+    in this schema, if any.
+    */
+  linebreakReplacement: NodeType$1 | null;
+  /**
+    Construct a schema from a schema [specification](https://prosemirror.net/docs/ref/#model.SchemaSpec).
+    */
+  constructor(spec: SchemaSpec<Nodes, Marks>);
+  /**
+    The type of the [default top node](https://prosemirror.net/docs/ref/#model.SchemaSpec.topNode)
+    for this schema.
+    */
+  topNodeType: NodeType$1;
+  /**
+    An object for storing whatever values modules may want to
+    compute and cache per schema. (If you want to store something
+    in it, try to use property names unlikely to clash.)
+    */
+  cached: {
+    [key: string]: any;
+  };
+  /**
+    Create a node in this schema. The `type` may be a string or a
+    `NodeType` instance. Attributes will be extended with defaults,
+    `content` may be a `Fragment`, `null`, a `Node`, or an array of
+    nodes.
+    */
+  node(type: string | NodeType$1, attrs?: Attrs$1 | null, content?: Fragment | Node | readonly Node[], marks?: readonly Mark[]): Node;
+  /**
+    Create a text node in the schema. Empty text nodes are not
+    allowed.
+    */
+  text(text: string, marks?: readonly Mark[] | null): Node;
+  /**
+    Create a mark with the given type and attributes.
+    */
+  mark(type: string | MarkType$1, attrs?: Attrs$1 | null): Mark;
+  /**
+    Deserialize a node from its JSON representation. This method is
+    bound.
+    */
+  nodeFromJSON: (json: any) => Node;
+  /**
+    Deserialize a mark from its JSON representation. This method is
+    bound.
+    */
+  markFromJSON: (json: any) => Mark;
+}
+/**
+A fragment represents a node's collection of child nodes.
+
+Like nodes, fragments are persistent data structures, and you
+should not mutate them or their content. Rather, you create new
+instances whenever needed. The API tries to make this easy.
+*/
+declare class Fragment {
+  /**
+    The child nodes in this fragment.
+    */
+  readonly content: readonly Node[];
+  /**
+    The size of the fragment, which is the total of the size of
+    its content nodes.
+    */
+  readonly size: number;
+  /**
+    Invoke a callback for all descendant nodes between the given two
+    positions (relative to start of this fragment). Doesn't descend
+    into a node when the callback returns `false`.
+    */
+  nodesBetween(from: number, to: number, f: (node: Node, start: number, parent: Node | null, index: number) => boolean | void, nodeStart?: number, parent?: Node): void;
+  /**
+    Call the given callback for every descendant node. `pos` will be
+    relative to the start of the fragment. The callback may return
+    `false` to prevent traversal of a given node's children.
+    */
+  descendants(f: (node: Node, pos: number, parent: Node | null, index: number) => boolean | void): void;
+  /**
+    Extract the text between `from` and `to`. See the same method on
+    [`Node`](https://prosemirror.net/docs/ref/#model.Node.textBetween).
+    */
+  textBetween(from: number, to: number, blockSeparator?: string | null, leafText?: string | null | ((leafNode: Node) => string)): string;
+  /**
+    Create a new fragment containing the combined content of this
+    fragment and the other.
+    */
+  append(other: Fragment): Fragment;
+  /**
+    Cut out the sub-fragment between the two given positions.
+    */
+  cut(from: number, to?: number): Fragment;
+  /**
+    Create a new fragment in which the node at the given index is
+    replaced by the given node.
+    */
+  replaceChild(index: number, node: Node): Fragment;
+  /**
+    Create a new fragment by prepending the given node to this
+    fragment.
+    */
+  addToStart(node: Node): Fragment;
+  /**
+    Create a new fragment by appending the given node to this
+    fragment.
+    */
+  addToEnd(node: Node): Fragment;
+  /**
+    Compare this fragment to another one.
+    */
+  eq(other: Fragment): boolean;
+  /**
+    The first child of the fragment, or `null` if it is empty.
+    */
+  get firstChild(): Node | null;
+  /**
+    The last child of the fragment, or `null` if it is empty.
+    */
+  get lastChild(): Node | null;
+  /**
+    The number of child nodes in this fragment.
+    */
+  get childCount(): number;
+  /**
+    Get the child node at the given index. Raise an error when the
+    index is out of range.
+    */
+  child(index: number): Node;
+  /**
+    Get the child node at the given index, if it exists.
+    */
+  maybeChild(index: number): Node | null;
+  /**
+    Call `f` for every child node, passing the node, its offset
+    into this parent node, and its index.
+    */
+  forEach(f: (node: Node, offset: number, index: number) => void): void;
+  /**
+    Find the first position at which this fragment and another
+    fragment differ, or `null` if they are the same.
+    */
+  findDiffStart(other: Fragment, pos?: number): number | null;
+  /**
+    Find the first position, searching from the end, at which this
+    fragment and the given fragment differ, or `null` if they are
+    the same. Since this position will not be the same in both
+    nodes, an object with two separate positions is returned.
+    */
+  findDiffEnd(other: Fragment, pos?: number, otherPos?: number): {
+    a: number;
+    b: number;
+  } | null;
+  /**
+    Return a debugging string that describes this fragment.
+    */
+  toString(): string;
+  /**
+    Create a JSON-serializeable representation of this fragment.
+    */
+  toJSON(): any;
+  /**
+    Deserialize a fragment from its JSON representation.
+    */
+  static fromJSON(schema: Schema$1, value: any): Fragment;
+  /**
+    Build a fragment from an array of nodes. Ensures that adjacent
+    text nodes with the same marks are joined together.
+    */
+  static fromArray(array: readonly Node[]): Fragment;
+  /**
+    Create a fragment from something that can be interpreted as a
+    set of nodes. For `null`, it returns the empty fragment. For a
+    fragment, the fragment itself. For a node or array of nodes, a
+    fragment containing those nodes.
+    */
+  static from(nodes?: Fragment | Node | readonly Node[] | null): Fragment;
+  /**
+    An empty fragment. Intended to be reused whenever a node doesn't
+    contain anything (rather than allocating a new empty fragment for
+    each leaf node).
+    */
+  static empty: Fragment;
+}
+type MatchEdge = {
+  type: NodeType$1;
+  next: ContentMatch;
+};
+/**
+Instances of this class represent a match state of a node type's
+[content expression](https://prosemirror.net/docs/ref/#model.NodeSpec.content), and can be used to
+find out whether further content matches here, and whether a given
+position is a valid end of the node.
+*/
+declare class ContentMatch {
+  /**
+    True when this match state represents a valid end of the node.
+    */
+  readonly validEnd: boolean;
+  /**
+    Match a node type, returning a match after that node if
+    successful.
+    */
+  matchType(type: NodeType$1): ContentMatch | null;
+  /**
+    Try to match a fragment. Returns the resulting match when
+    successful.
+    */
+  matchFragment(frag: Fragment, start?: number, end?: number): ContentMatch | null;
+  /**
+    Get the first matching node type at this match position that can
+    be generated.
+    */
+  get defaultType(): NodeType$1 | null;
+  /**
+    Try to match the given fragment, and if that fails, see if it can
+    be made to match by inserting nodes in front of it. When
+    successful, return a fragment of inserted nodes (which may be
+    empty if nothing had to be inserted). When `toEnd` is true, only
+    return a fragment if the resulting match goes to the end of the
+    content expression.
+    */
+  fillBefore(after: Fragment, toEnd?: boolean, startIndex?: number): Fragment | null;
+  /**
+    Find a set of wrapping node types that would allow a node of the
+    given type to appear at this position. The result may be empty
+    (when it fits directly) and will be null when no such wrapping
+    exists.
+    */
+  findWrapping(target: NodeType$1): readonly NodeType$1[] | null;
+  /**
+    The number of outgoing edges this node has in the finite
+    automaton that describes the content expression.
+    */
+  get edgeCount(): number;
+  /**
+    Get the _n_​th outgoing edge from this node in the finite
+    automaton that describes the content expression.
+    */
+  edge(n: number): MatchEdge;
+}
+/**
+This class represents a node in the tree that makes up a
+ProseMirror document. So a document is an instance of `Node`, with
+children that are also instances of `Node`.
+
+Nodes are persistent data structures. Instead of changing them, you
+create new ones with the content you want. Old ones keep pointing
+at the old document shape. This is made cheaper by sharing
+structure between the old and new data as much as possible, which a
+tree shape like this (without back pointers) makes easy.
+
+**Do not** directly mutate the properties of a `Node` object. See
+[the guide](https://prosemirror.net/docs/guide/#doc) for more information.
+*/
+declare class Node {
+  /**
+    The type of node that this is.
+    */
+  readonly type: NodeType$1;
+  /**
+    An object mapping attribute names to values. The kind of
+    attributes allowed and required are
+    [determined](https://prosemirror.net/docs/ref/#model.NodeSpec.attrs) by the node type.
+    */
+  readonly attrs: Attrs$1;
+  /**
+    The marks (things like whether it is emphasized or part of a
+    link) applied to this node.
+    */
+  readonly marks: readonly Mark[];
+  /**
+    A container holding the node's children.
+    */
+  readonly content: Fragment;
+  /**
+    The array of this node's child nodes.
+    */
+  get children(): readonly Node[];
+  /**
+    For text nodes, this contains the node's text content.
+    */
+  readonly text: string | undefined;
+  /**
+    The size of this node, as defined by the integer-based [indexing
+    scheme](https://prosemirror.net/docs/guide/#doc.indexing). For text nodes, this is the
+    amount of characters. For other leaf nodes, it is one. For
+    non-leaf nodes, it is the size of the content plus two (the
+    start and end token).
+    */
+  get nodeSize(): number;
+  /**
+    The number of children that the node has.
+    */
+  get childCount(): number;
+  /**
+    Get the child node at the given index. Raises an error when the
+    index is out of range.
+    */
+  child(index: number): Node;
+  /**
+    Get the child node at the given index, if it exists.
+    */
+  maybeChild(index: number): Node | null;
+  /**
+    Call `f` for every child node, passing the node, its offset
+    into this parent node, and its index.
+    */
+  forEach(f: (node: Node, offset: number, index: number) => void): void;
+  /**
+    Invoke a callback for all descendant nodes recursively overlapping
+    the given two positions that are relative to start of this
+    node's content. This includes all ancestors of the nodes
+    containing the two positions. The callback is invoked with the
+    node, its position relative to the original node (method receiver),
+    its parent node, and its child index. When the callback returns
+    false for a given node, that node's children will not be
+    recursed over. The last parameter can be used to specify a
+    starting position to count from.
+    */
+  nodesBetween(from: number, to: number, f: (node: Node, pos: number, parent: Node | null, index: number) => void | boolean, startPos?: number): void;
+  /**
+    Call the given callback for every descendant node. Doesn't
+    descend into a node when the callback returns `false`.
+    */
+  descendants(f: (node: Node, pos: number, parent: Node | null, index: number) => void | boolean): void;
+  /**
+    Concatenates all the text nodes found in this fragment and its
+    children.
+    */
+  get textContent(): string;
+  /**
+    Get all text between positions `from` and `to`. When
+    `blockSeparator` is given, it will be inserted to separate text
+    from different block nodes. If `leafText` is given, it'll be
+    inserted for every non-text leaf node encountered, otherwise
+    [`leafText`](https://prosemirror.net/docs/ref/#model.NodeSpec.leafText) will be used.
+    */
+  textBetween(from: number, to: number, blockSeparator?: string | null, leafText?: null | string | ((leafNode: Node) => string)): string;
+  /**
+    Returns this node's first child, or `null` if there are no
+    children.
+    */
+  get firstChild(): Node | null;
+  /**
+    Returns this node's last child, or `null` if there are no
+    children.
+    */
+  get lastChild(): Node | null;
+  /**
+    Test whether two nodes represent the same piece of document.
+    */
+  eq(other: Node): boolean;
+  /**
+    Compare the markup (type, attributes, and marks) of this node to
+    those of another. Returns `true` if both have the same markup.
+    */
+  sameMarkup(other: Node): boolean;
+  /**
+    Check whether this node's markup correspond to the given type,
+    attributes, and marks.
+    */
+  hasMarkup(type: NodeType$1, attrs?: Attrs$1 | null, marks?: readonly Mark[]): boolean;
+  /**
+    Create a new node with the same markup as this node, containing
+    the given content (or empty, if no content is given).
+    */
+  copy(content?: Fragment | null): Node;
+  /**
+    Create a copy of this node, with the given set of marks instead
+    of the node's own marks.
+    */
+  mark(marks: readonly Mark[]): Node;
+  /**
+    Create a copy of this node with only the content between the
+    given positions. If `to` is not given, it defaults to the end of
+    the node.
+    */
+  cut(from: number, to?: number): Node;
+  /**
+    Cut out the part of the document between the given positions, and
+    return it as a `Slice` object.
+    */
+  slice(from: number, to?: number, includeParents?: boolean): Slice;
+  /**
+    Replace the part of the document between the given positions with
+    the given slice. The slice must 'fit', meaning its open sides
+    must be able to connect to the surrounding content, and its
+    content nodes must be valid children for the node they are placed
+    into. If any of this is violated, an error of type
+    [`ReplaceError`](https://prosemirror.net/docs/ref/#model.ReplaceError) is thrown.
+    */
+  replace(from: number, to: number, slice: Slice): Node;
+  /**
+    Find the node directly after the given position.
+    */
+  nodeAt(pos: number): Node | null;
+  /**
+    Find the (direct) child node after the given offset, if any,
+    and return it along with its index and offset relative to this
+    node.
+    */
+  childAfter(pos: number): {
+    node: Node | null;
+    index: number;
+    offset: number;
+  };
+  /**
+    Find the (direct) child node before the given offset, if any,
+    and return it along with its index and offset relative to this
+    node.
+    */
+  childBefore(pos: number): {
+    node: Node | null;
+    index: number;
+    offset: number;
+  };
+  /**
+    Resolve the given position in the document, returning an
+    [object](https://prosemirror.net/docs/ref/#model.ResolvedPos) with information about its context.
+    */
+  resolve(pos: number): ResolvedPos;
+  /**
+    Test whether a given mark or mark type occurs in this document
+    between the two given positions.
+    */
+  rangeHasMark(from: number, to: number, type: Mark | MarkType$1): boolean;
+  /**
+    True when this is a block (non-inline node)
+    */
+  get isBlock(): boolean;
+  /**
+    True when this is a textblock node, a block node with inline
+    content.
+    */
+  get isTextblock(): boolean;
+  /**
+    True when this node allows inline content.
+    */
+  get inlineContent(): boolean;
+  /**
+    True when this is an inline node (a text node or a node that can
+    appear among text).
+    */
+  get isInline(): boolean;
+  /**
+    True when this is a text node.
+    */
+  get isText(): boolean;
+  /**
+    True when this is a leaf node.
+    */
+  get isLeaf(): boolean;
+  /**
+    True when this is an atom, i.e. when it does not have directly
+    editable content. This is usually the same as `isLeaf`, but can
+    be configured with the [`atom` property](https://prosemirror.net/docs/ref/#model.NodeSpec.atom)
+    on a node's spec (typically used when the node is displayed as
+    an uneditable [node view](https://prosemirror.net/docs/ref/#view.NodeView)).
+    */
+  get isAtom(): boolean;
+  /**
+    Return a string representation of this node for debugging
+    purposes.
+    */
+  toString(): string;
+  /**
+    Get the content match in this node at the given index.
+    */
+  contentMatchAt(index: number): ContentMatch;
+  /**
+    Test whether replacing the range between `from` and `to` (by
+    child index) with the given replacement fragment (which defaults
+    to the empty fragment) would leave the node's content valid. You
+    can optionally pass `start` and `end` indices into the
+    replacement fragment.
+    */
+  canReplace(from: number, to: number, replacement?: Fragment, start?: number, end?: number): boolean;
+  /**
+    Test whether replacing the range `from` to `to` (by index) with
+    a node of the given type would leave the node's content valid.
+    */
+  canReplaceWith(from: number, to: number, type: NodeType$1, marks?: readonly Mark[]): boolean;
+  /**
+    Test whether the given node's content could be appended to this
+    node. If that node is empty, this will only return true if there
+    is at least one node type that can appear in both nodes (to avoid
+    merging completely incompatible nodes).
+    */
+  canAppend(other: Node): boolean;
+  /**
+    Check whether this node and its descendants conform to the
+    schema, and raise an exception when they do not.
+    */
+  check(): void;
+  /**
+    Return a JSON-serializeable representation of this node.
+    */
+  toJSON(): any;
+  /**
+    Deserialize a node from its JSON representation.
+    */
+  static fromJSON(schema: Schema$1, json: any): Node;
+}
+/**
+Convert a union type to an intersection type.
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void} & {great(arg: string): void} & {escape: boolean}
+```
+
+@category Type
+*/
+type UnionToIntersection<Union> = (
+// `extends unknown` is always going to be the case and is used to convert the
+// `Union` into a [distributive conditional
+// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+Union extends unknown ?
+// The union type is used as the only argument to a function since the union
+// of function arguments is an intersection.
+(distributedUnion: Union) => void :
+// This won't happen.
+never
+// Infer the `Intersection` type since TypeScript represents the positional
+// arguments of unions of functions as an intersection of the union.
+) extends ((mergedIntersection: infer Intersection) => void) ?
+// The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
+Intersection & Union : never;
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+declare function fn(object: Record<string, unknown>): void;
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+// @ts-expect-error
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see {@link SimplifyDeep}
+@category Object
+*/
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType]; } & {};
+/**
+ * @internal
+ */
+interface CommandTyping {
+  [name: string]: any[];
+}
+/**
+ * @internal
+ */
+interface MarkTyping {
+  [name: string]: Record<string, any>;
+}
+/**
+ * @internal
+ */
+interface NodeTyping {
+  [name: string]: Record<string, any>;
+}
+/**
+ * @internal
+ */
+type PickSubType<Type, ParentType> = Type extends ParentType ? [ParentType] extends [Type] ? never : Type : never;
+/**
+ * ProseKit extension priority.
+ *
+ * There are five priority levels available:
+ *
+ * - `Priority.lowest`
+ * - `Priority.low`
+ * - `Priority.default`
+ * - `Priority.high`
+ * - `Priority.highest`
+ *
+ * @example
+ *
+ * ```ts
+ * import { withPriority, Priority } from 'prosekit/core'
+ * import { myExtension } from './my-extension.js'
+ *
+ * const myExtensionWithHighPriority = withPriority(myExtension, Priority.high)
+ * ```
+ */
+declare const Priority: {
+  readonly lowest: 0;
+  readonly low: 1;
+  readonly default: 2;
+  readonly high: 3;
+  readonly highest: 4;
+};
+/**
+ * ProseKit extension priority.
+ *
+ * There are five priority levels available:
+ *
+ * - `Priority.lowest`
+ * - `Priority.low`
+ * - `Priority.default`
+ * - `Priority.high`
+ * - `Priority.highest`
+ *
+ * @example
+ *
+ * ```ts
+ * import { withPriority, Priority } from 'prosekit/core'
+ * import { myExtension } from './my-extension.js'
+ *
+ * const myExtensionWithHighPriority = withPriority(myExtension, Priority.high)
+ * ```
+ */
+type Priority = typeof Priority[keyof typeof Priority];
+/**
+ * @internal
+ */
+type SimplifyDeeper<T> = { [KeyType in keyof T]: Simplify<T[KeyType]>; };
+/**
+ * @internal
+ */
+type SimplifyUnion<T> = Simplify<UnionToIntersection<T extends undefined ? never : T>>;
+/**
+ * @internal
+ */
+interface ExtensionTyping<N extends NodeTyping = never, M extends MarkTyping = never, C extends CommandTyping = never> {
+  Nodes?: N;
+  Marks?: M;
+  Commands?: C;
+}
+interface Extension$1<T extends ExtensionTyping<any, any, any> = ExtensionTyping<any, any, any>> {
+  extension: Extension$1 | Extension$1[];
+  priority?: Priority;
+  /**
+   * The schema that this extension represents.
+   */
+  schema: Schema | null;
+  /** @internal */
+  _type?: T;
+}
+/**
+ * @internal
+ */
+type ExtractTyping<E extends Extension$1> = E extends Extension$1<ExtensionTyping<infer N, infer M, infer C>> ? ExtensionTyping<PickSubType<N, NodeTyping>, PickSubType<M, MarkTyping>, PickSubType<C, CommandTyping>> : never;
+/**
+ * An extension that does not define any nodes, marks, or commands.
+ *
+ * @internal
+ */
+type PlainExtension = Extension$1<{
+  Nodes: never;
+  Marks: never;
+  Commands: never;
+}>;
+type ExtractNodes<E extends Extension$1> = SimplifyDeeper<SimplifyUnion<ExtractTyping<E>['Nodes']>>;
+type ExtractMarks<E extends Extension$1> = SimplifyDeeper<SimplifyUnion<ExtractTyping<E>['Marks']>>;
+/**
+ * @internal
+ */
+type ExtractCommands<E extends Extension$1> = SimplifyUnion<ExtractTyping<E>['Commands']>;
+/**
+ * @internal
+ */
+type Union<E extends readonly Extension$1[]> = Extension$1<{
+  Nodes: ExtractNodes<E[number]>;
+  Marks: ExtractMarks<E[number]>;
+  Commands: ExtractCommands<E[number]>;
+}>;
+interface AddMarkOptions {
+  /**
+   * The type of the mark to add.
+   */
+  type: string | MarkType;
+  /**
+   * The attributes of the mark to add.
+   */
+  attrs?: Attrs | null;
+  /**
+   * The start position of the document. By default it will be the start position of current selection.
+   */
+  from?: number;
+  /**
+   * The end position of the document. By default it will be the end position of current selection.
+   */
+  to?: number;
+}
+interface InsertDefaultBlockOptions {
+  /**
+   * The position to insert the node at. By default it will insert after the
+   * current selection.
+   */
+  pos?: number;
+}
+interface InsertNodeOptions {
+  /**
+   * The node to insert. Either this or `type` must be provided.
+   */
+  node?: ProseMirrorNode;
+  /**
+   * The type of the node to insert. Either this or `node` must be provided.
+   */
+  type?: string | NodeType;
+  /**
+   * When `type` is provided, the attributes of the node to insert.
+   */
+  attrs?: Attrs;
+  /**
+   * The position to insert the node at. By default it will be the anchor
+   * position of current selection.
+   */
+  pos?: number;
+}
+interface RemoveMarkOptions {
+  /**
+   * The type of the mark to remove.
+   */
+  type: string | MarkType;
+  /**
+   * If attrs is given, remove precisely the mark with the given attrs. Otherwise, remove all marks of the given type.
+   */
+  attrs?: Attrs | null;
+  /**
+   * The start position of the document. By default it will be the start position of current selection.
+   */
+  from?: number;
+  /**
+   * The end position of the document. By default it will be the end position of current selection.
+   */
+  to?: number;
+}
+interface RemoveNodeOptions {
+  /**
+   * The type of the node to remove.
+   */
+  type: string | NodeType;
+  /**
+   * The document position to start searching for the node. By default, it will
+   * use the anchor position of current selection.
+   */
+  pos?: number;
+}
+interface SetBlockTypeOptions {
+  type: NodeType | string;
+  attrs?: Attrs | null;
+  from?: number;
+  to?: number;
+}
+interface SetNodeAttrsBetweenOptions {
+  /**
+   * The type of node to set the attributes of.
+   */
+  type: string | NodeType | string[] | NodeType[];
+  /**
+   * The attributes to set.
+   */
+  attrs: Attrs;
+  /**
+   * The position to start searching for nodes. By default, the selection from position will be used.
+   */
+  from?: number;
+  /**
+   * The position to end searching for nodes. By default, the selection to position will be used.
+   */
+  to?: number;
+}
+interface SetNodeAttrsOptions {
+  /**
+   * The type of node to set the attributes of.
+   */
+  type: string | NodeType | string[] | NodeType[];
+  /**
+   * The attributes to set.
+   */
+  attrs: Attrs;
+  /**
+   * The document position of the node to update. If not provided, the command
+   * will find the closest ancestor node that matches the type based on the
+   * anchor position of the selection.
+   */
+  pos?: number;
+}
+interface ToggleWrapOptions {
+  /**
+   * The type of the node to toggle.
+   */
+  type: string | NodeType;
+  /**
+   * The attributes of the node to toggle.
+   */
+  attrs?: Attrs | null;
+}
+interface UnsetBlockTypeOptions {
+  /**
+   * The start position of the document. By default it will be the start position of current selection.
+   */
+  from?: number;
+  /**
+   * The end position of the document. By default it will be the end position of current selection.
+   */
+  to?: number;
+}
+/**
+ * Options for {@link unsetMark}.
+ */
+interface UnsetMarkOptions {
+  /**
+   * The start position of the document. By default it will be the start position of current selection.
+   */
+  from?: number;
+  /**
+   * The end position of the document. By default it will be the end position of current selection.
+   */
+  to?: number;
+}
+interface WrapOptions {
+  /**
+   * The node type to wrap the selected textblock with.
+   */
+  type: NodeType | string;
+  /**
+   * Optional attributes to apply to the node.
+   */
+  attrs?: Attrs | null;
+}
+type InsertTextOptions = {
+  text: string;
+  from?: number;
+  to?: number;
+};
+/**
+ * @internal
+ */
+type BaseCommandsExtension = Extension$1<{
+  Commands: {
+    insertText: [options: InsertTextOptions];
+    insertNode: [options: InsertNodeOptions];
+    removeNode: [options: RemoveNodeOptions];
+    wrap: [options: WrapOptions];
+    toggleWrap: [options: ToggleWrapOptions];
+    setBlockType: [options: SetBlockTypeOptions];
+    setNodeAttrs: [options: SetNodeAttrsOptions];
+    setNodeAttrsBetween: [options: SetNodeAttrsBetweenOptions];
+    insertDefaultBlock: [options?: InsertDefaultBlockOptions];
+    selectAll: [];
+    selectBlock: [];
+    addMark: [options: AddMarkOptions];
+    removeMark: [options: RemoveMarkOptions];
+    unsetBlockType: [options?: UnsetBlockTypeOptions];
+    unsetMark: [options?: UnsetMarkOptions];
+  };
+}>;
+/**
+ * @internal
+ */
+type HistoryExtension = Extension$1<{
+  Commands: {
+    undo: [];
+    redo: [];
+  };
+}>;
+/**
+ * @internal
+ */
+type BoldCommandsExtension = Extension$1<{
+  Commands: {
+    toggleBold: [];
+  };
+}>;
+/**
+ * @internal
+ */
+type BoldSpecExtension = Extension$1<{
+  Marks: {
+    bold: Attrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type BoldExtension$1 = Union<[BoldSpecExtension, BoldCommandsExtension]>;
+/**
+ * @internal
+ */
+type ItalicCommandsExtension = Extension$1<{
+  Commands: {
+    toggleItalic: [];
+  };
+}>;
+/**
+ * @internal
+ */
+type ItalicSpecExtension = Extension$1<{
+  Marks: {
+    italic: Attrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type ItalicExtension$1 = Union<[ItalicSpecExtension, ItalicCommandsExtension]>;
+/**
+ * @internal
+ */
+type UnderlineSpecExtension = Extension$1<{
+  Marks: {
+    underline: Attrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type UnderlineCommandsExtension = Extension$1<{
+  Commands: {
+    toggleUnderline: [];
+  };
+}>;
+/**
+ * @internal
+ */
+type UnderlineExtension$1 = Union<[UnderlineSpecExtension, UnderlineCommandsExtension]>;
+/**
+ * @internal
+ */
+type StrikeSpecExtension = Extension$1<{
+  Marks: {
+    strike: Attrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type StrikeCommandsExtension = Extension$1<{
+  Commands: {
+    toggleStrike: [];
+  };
+}>;
+/**
+ * @internal
+ */
+type StrikeExtension$1 = Union<[StrikeSpecExtension, StrikeCommandsExtension]>;
+/**
+ * @internal
+ */
+type CodeCommandsExtension = Extension$1<{
+  Commands: {
+    toggleCode: [];
+  };
+}>;
+/**
+ * @internal
+ */
+type CodeSpecExtension = Extension$1<{
+  Marks: {
+    code: Attrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type CodeExtension$1 = Union<[CodeSpecExtension, CodeCommandsExtension]>;
+interface LinkAttrs {
+  href: string;
+  target?: string | null;
+  rel?: string | null;
+}
+/**
+ * @internal
+ */
+type LinkSpecExtension = Extension$1<{
+  Marks: {
+    link: LinkAttrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type LinkCommandsExtension = Extension$1<{
+  Commands: {
+    addLink: [attrs: LinkAttrs];
+    removeLink: [];
+    toggleLink: [attrs: LinkAttrs];
+    expandLink: [];
+  };
+}>;
+/**
+ * @internal
+ */
+type LinkExtension$1 = Union<[LinkSpecExtension, LinkCommandsExtension]>;
+/** The `highlight` mark: a run of text marked for attention, rendered `<mark>`. */
+export declare function defineHighlight(): Extension$1<{
+  Marks: {
+    highlight: Attrs$1;
+  };
+}>;
+/**
+ * The `subscript` mark, rendered `<sub>`.
+ *
+ * Excludes {@link defineSuperscript}'s mark: a run of text is one or the
+ * other, never both, and ProseMirror enforces that at the model level rather
+ * than leaving it to the toolbar.
+ */
+export declare function defineSubscript(): Extension$1<{
+  Marks: {
+    subscript: Attrs$1;
+  };
+}>;
+/** The `superscript` mark, rendered `<sup>`; excludes `subscript` — see {@link defineSubscript}. */
+export declare function defineSuperscript(): Extension$1<{
+  Marks: {
+    superscript: Attrs$1;
+  };
+}>;
+/**
+ * An inline mark binding a run of text to a cited work by id, rendered
+ * `<cite data-work-id>`.
+ *
+ * A mark rather than a node, deliberately: marks carry no content, so a
+ * citation annotates a run of prose and can never swallow structure the way a
+ * footnote node could. `workId` is a caller-owned handle and is emitted as a
+ * data attribute, never as a URL.
+ *
+ * Opt-in: not part of {@link defineStandardMarks}, because adding it changes
+ * what the derived wire schema accepts.
+ */
+export declare function defineCitation(): Extension$1<{
+  Marks: {
+    citation: {
+      workId: string;
+    };
+  };
+}>;
+/**
+ * The nine marks both presets in `./presets.ts` compose: ProseKit's `bold`,
+ * `italic`, `underline`, `strike`, `code` and `link`, plus this library's
+ * `highlight`, `subscript` and `superscript`.
+ *
+ * `citation` is not in the set — it is opt-in, and an application that wants
+ * it passes `defineCitation()` as an extra to the preset.
+ */
+export declare function defineStandardMarks(): Union<readonly [BoldExtension$1, ItalicExtension$1, UnderlineExtension$1, StrikeExtension$1, CodeExtension$1, LinkExtension$1, Extension$1<{
+  Marks: {
+    highlight: Attrs$1;
+  };
+}>, Extension$1<{
+  Marks: {
+    subscript: Attrs$1;
+  };
+}>, Extension$1<{
+  Marks: {
+    superscript: Attrs$1;
+  };
+}>]>;
+/**
+ * A `doc` top node that accepts inline content only (`content: "inline*"`).
+ *
+ * The shape a single-line rich-text field wants: marks and text, no
+ * paragraphs, no blocks. Each compiled schema owns its own node registry, so
+ * this never conflicts with the stock `defineDoc()` (`content: "block+"`) —
+ * the two simply belong to different extensions.
+ */
+export declare function defineInlineDoc(): Extension$1<{
+  Nodes: {
+    doc: Attrs$1;
+  };
+}>;
+/**
+ * An inline atom that points at an entity by id and carries the text to
+ * render for it — the `@name` shape.
+ *
+ * `id` is the stable handle a consumer resolves (a notification fan-out, a
+ * profile link); `label` is display text and is untrusted, which is why
+ * `toDOM` emits it as a text child rather than as markup. The node is an
+ * atom, so nothing can be typed inside it and the label only ever changes by
+ * replacing the whole node.
+ *
+ * This is deliberately **not** `prosekit/extensions/mention`: ProseKit's stock
+ * mention carries a different attribute shape, and this one is wire-identical
+ * to documents the source applications have already persisted.
+ */
+export declare function defineMention(): Extension$1<{
+  Nodes: {
+    mention: {
+      id: string;
+      label: string;
+    };
+  };
+}>;
+/**
+ * The caption half of a figure: inline content only.
+ *
+ * `content: "inline*"` rather than `block+` is what stops a caption nesting a
+ * paragraph, a list, or another figure — a caption is a line of prose, and
+ * the derived wire schema enforces exactly that because it reads this content
+ * expression off the compiled schema.
+ *
+ * The derived wire schema does not, however, require a figure to carry a
+ * caption: see {@link defineFigureNode} for what it does and does not enforce
+ * about the pair.
+ */
+export declare function defineFigcaption(): Extension$1<{
+  Nodes: {
+    figcaption: Attrs$1;
+  };
+}>;
+/**
+ * A captioned image block: in the editor, exactly one `image` followed by
+ * exactly one `figcaption`.
+ *
+ * The fixed content expression is the point — a figure is a pair, not a
+ * container, so ProseMirror's DOM parser and its editing transactions never
+ * let either half be dropped or duplicated. `defining` keeps the figure as its
+ * own context on paste rather than dissolving into the surrounding block.
+ *
+ * Loading JSON is not checked the same way: ProseMirror's
+ * `schema.nodeFromJSON` validates attributes but not content, and ProseKit's
+ * `defaultContent` goes through it, so a stored captionless figure loads into
+ * an editor unchecked. A consumer that wants the content expression enforced
+ * on a loaded document calls `node.check()`, which ProseKit's
+ * `editor.setContent` already does.
+ *
+ * The derived wire schema is deliberately laxer. Derivation reads the set of
+ * admissible children and the empty-vs-non-empty distinction off the compiled
+ * content expression, not the ordered sequence (see `derive/Content`), so a
+ * stored `figure` decodes when its `content` is any non-empty array of `image`
+ * and `figcaption` nodes: a figure without a figcaption, a figcaption alone,
+ * the halves reordered or one duplicated all decode. An empty figure and any
+ * other child type are still rejected. A consumer that needs the pair enforced
+ * at the wire adds its own check, for example `node.check()` on the node it
+ * builds from the decoded JSON.
+ *
+ * Use {@link defineFigure} unless you are composing the two halves yourself:
+ * this node is unusable without {@link defineFigcaption} in the same
+ * extension, and the stock `image` node besides.
+ */
+export declare function defineFigureNode(): Extension$1<{
+  Nodes: {
+    figure: Attrs$1;
+  };
+}>;
+/** {@link defineFigureNode} together with its {@link defineFigcaption} child. */
+export declare function defineFigure(): Union<readonly [Extension$1<{
+  Nodes: {
+    figure: Attrs$1;
+  };
+}>, Extension$1<{
+  Nodes: {
+    figcaption: Attrs$1;
+  };
+}>]>;
+/**
+ * An inline aside that sits alongside the body prose — a reference note the
+ * reader can take or leave, rendered in the margin on wide viewports and as a
+ * footnote-like inline block on narrow ones.
+ *
+ * The note holds **rich inline content** (text plus the surrounding marks),
+ * not a plain-text attribute, so a link or emphasis inside a note round-trips
+ * through the node's own children on every surface: the editor, the HTML
+ * serialiser, the Markdown walk and paste.
+ *
+ * It is `inline: true` but deliberately **not** `atom`: that is what lets the
+ * cursor enter the note and edit its content in place with the same toolbar
+ * that styles body prose, with no nested editor and no node view. An `atom`
+ * inline node cannot hold editable inline children without one. `selectable`
+ * makes the whole note pickable; `defining` keeps its boundary on paste.
+ *
+ * Its content is `(text | hardBreak)*` — the two text-like inline nodes by
+ * name, not the broad `inline` group — so **a note can never nest a note**.
+ * `sidenote` is itself in group `inline`, so `content: "inline*"` would admit
+ * `^[…^[…]…]`, which has no valid inline-footnote rendering in Markdown; the
+ * derived wire schema reads this very expression off the compiled schema and
+ * rejects the nesting for free.
+ *
+ * Placement is a render-time, CSS-only concern: the node is layout-agnostic
+ * and ships no styles.
+ */
+export declare function defineSidenote(): Extension$1<{
+  Nodes: {
+    sidenote: Attrs$1;
+  };
+}>;
+/**
+ * @internal
+ */
+type DocExtension$1 = Extension$1<{
+  Nodes: {
+    doc: Attrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type TextExtension$1 = Extension$1<{
+  Nodes: {
+    text: Attrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type ParagraphCommandsExtension = Extension$1<{
+  Commands: {
+    setParagraph: [];
+  };
+}>;
+/**
+ * @internal
+ */
+type ParagraphSpecExtension = Extension$1<{
+  Nodes: {
+    paragraph: Attrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type ParagraphExtension$1 = Union<[ParagraphSpecExtension, ParagraphCommandsExtension]>;
+interface HeadingAttrs {
+  level: number;
+}
+/**
+ * @internal
+ */
+type HeadingCommandsExtension = Extension$1<{
+  Commands: {
+    setHeading: [attrs?: HeadingAttrs | undefined];
+    insertHeading: [attrs?: HeadingAttrs | undefined];
+    toggleHeading: [attrs?: HeadingAttrs | undefined];
+  };
+}>;
+/**
+ * @internal
+ */
+type HeadingSpecExtension = Extension$1<{
+  Nodes: {
+    heading: HeadingAttrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type HeadingExtension$1 = Union<[HeadingSpecExtension, HeadingCommandsExtension]>;
+declare global {
+  interface Node {}
+}
+//#region src/commands/dedent-list.d.ts
+/**
+ * @public
+ *
+ * @group Commands
+ */
+interface DedentListOptions {
+  /**
+   * A optional from position to indent.
+   *
+   * @defaultValue `state.selection.from`
+   */
+  from?: number;
+  /**
+   * A optional to position to indent.
+   *
+   * @defaultValue `state.selection.to`
+   */
+  to?: number;
+  /**
+   * When `true`, the command never leaves a list node whose first child is a
+   * list node (a list node with a hidden marker). The blocks after the
+   * dedented block move one level up with it instead of keeping their depth
+   * inside such a node, so a block is never more than one level deeper than
+   * the block before it.
+   *
+   * @defaultValue `false`
+   */
+  strict?: boolean;
+}
+//#endregion
+//#region src/commands/indent-list.d.ts
+/**
+ * @public
+ *
+ * @group Commands
+ */
+interface IndentListOptions {
+  /**
+   * A optional from position to indent.
+   *
+   * @defaultValue `state.selection.from`
+   */
+  from?: number;
+  /**
+   * A optional to position to indent.
+   *
+   * @defaultValue `state.selection.to`
+   */
+  to?: number;
+  /**
+   * When `true`, the command never leaves a list node whose first child is a
+   * list node (a list node with a hidden marker). It returns `false` instead
+   * of indenting a block that has no previous list sibling to move into, so a
+   * block is never more than one level deeper than the block before it.
+   *
+   * @defaultValue `false`
+   */
+  strict?: boolean;
+}
+//#endregion
+//#region src/commands/split-list.d.ts
+/**
+ * @public
+ *
+ * @group Commands
+ */
+interface SplitListOptions {
+  /**
+   * When `true`, the command never leaves a list node whose first child is a
+   * list node (a list node with a hidden marker). `Enter` in an empty list
+   * node dedents it, so this is the `strict` option of
+   * `createDedentListCommand`.
+   *
+   * @defaultValue `false`
+   */
+  strict?: boolean;
+}
+/**
+ * @public
+ *
+ * @group Schema
+ */
+interface ListAttributes {
+  kind?: string;
+  order?: number | null;
+  checked?: boolean;
+  collapsed?: boolean;
+}
+//#endregion
+//#region src/commands/toggle-collapsed.d.ts
+/**
+ * @public
+ *
+ * @group Commands
+ */
+interface ToggleCollapsedOptions {
+  /**
+   * If this value exists, the command will set the `collapsed` attribute to
+   * this value instead of toggle it.
+   */
+  collapsed?: boolean;
+  /**
+   * An optional function to accept a list node and return whether or not this
+   * node can toggle its `collapsed` attribute.
+   */
+  isToggleable?: (node: Node) => boolean;
+}
+//#endregion
+//#region src/commands/unwrap-list.d.ts
+/**
+ * @public
+ *
+ * @group Commands
+ */
+interface UnwrapListOptions {
+  /**
+   * If given, only this kind of list will be unwrap.
+   */
+  kind?: string;
+}
+/**
+ * @internal
+ */
+type ListCommandsExtension = Extension$1<{
+  Commands: {
+    dedentList: [options?: DedentListOptions];
+    indentList: [options?: IndentListOptions];
+    moveList: [direction: 'up' | 'down'];
+    splitList: [options?: SplitListOptions];
+    toggleCollapsed: [options?: ToggleCollapsedOptions];
+    unwrapList: [options?: UnwrapListOptions];
+    toggleList: [attrs?: ListAttributes];
+    wrapInList: [attrs?: ListAttributes];
+    insertList: [attrs?: ListAttributes];
+  };
+}>;
+/**
+ * The attributes of a list node.
+ */
+interface ListAttrs {
+  /**
+   * The kind of list node.
+   */
+  kind?: 'bullet' | 'ordered' | 'task' | 'toggle';
+  /**
+   * The optional order of the list node.
+   */
+  order?: number | null;
+  /**
+   * Whether the list node is checked if its `kind` is `"task"`.
+   */
+  checked?: boolean;
+  /**
+   * Whether the list node is collapsed if its `kind` is `"toggle"`.
+   */
+  collapsed?: boolean;
+}
+/**
+ * @internal
+ */
+type ListSpecExtension = Extension$1<{
+  Nodes: {
+    list: ListAttrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type ListExtension$1 = Union<[ListSpecExtension, ListCommandsExtension]>;
+type BlockquoteCommandsExtension = Extension$1<{
+  Commands: {
+    setBlockquote: [];
+    insertBlockquote: [];
+    toggleBlockquote: [];
+  };
+}>;
+type BlockquoteSpecExtension = Extension$1<{
+  Nodes: {
+    blockquote: Attrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type BlockquoteExtension$1 = Union<[BlockquoteSpecExtension, BlockquoteCommandsExtension]>;
+/**
+ * An interface representing the upload progress.
+ */
+interface UploadProgress {
+  loaded: number;
+  total: number;
+}
+interface UploaderOptions {
+  /**
+   * The file to be uploaded.
+   */
+  file: File;
+  /**
+   * A callback function that should be called with the upload progress updates.
+   */
+  onProgress: (progress: UploadProgress) => void;
+}
+/**
+ * The implementation of the actual upload function. You need to implement this
+ * function to upload files to your desired destination.
+ */
+type Uploader<Result> = (options: UploaderOptions) => Promise<Result>;
+/**
+ * A class that represents a upload task.
+ */
+declare class UploadTask<Result> {
+  /**
+   * An [object URL](https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL)
+   * representing the file to be uploaded. This URL will be revoked once the
+   * upload is complete successfully.
+   */
+  readonly objectURL: string;
+  /**
+   * A boolean indicating whether the upload is complete (either successfully or with an error).
+   */
+  protected done: boolean;
+  /**
+   * If the upload is complete successfully, this will be the result of the upload.
+   */
+  protected result: Result | undefined;
+  /**
+   * If the upload is complete with an error, this will be the error that occurred.
+   */
+  protected error: Error | undefined;
+  /**
+   * A promise that fulfills once the upload is complete, or rejects if an error occurs.
+   */
+  readonly finished: Promise<Result>;
+  private subscribers;
+  /**
+   * Creates a new upload task. You can find the upload task by its object URL
+   * later using `UploadTask.get()`.
+   *
+   * @param options - The options for the upload task.
+   */
+  constructor({ file, uploader }: {
+    file: File;
+    uploader: Uploader<Result>;
+  });
+  /**
+   * Subscribes to progress updates. Returns a function to unsubscribe.
+   */
+  subscribeProgress(callback: (progress: UploadProgress) => void): VoidFunction;
+  /**
+   * Finds an upload task from the global store by its object URL.
+   */
+  static get<Result = unknown>(objectURL: string): UploadTask<Result> | undefined;
+  /**
+   * Deletes an upload task from the global store by its object URL.
+   */
+  static delete(objectURL: string): void;
+}
+/**
+ * Options for {@link uploadImage}.
+ */
+interface UploadImageOptions {
+  /**
+   * The uploader used to upload the file. It should return a promise that
+   * resolves to the URL of the uploaded image.
+   */
+  uploader: Uploader<string>;
+  /**
+   * The file that will be uploaded.
+   */
+  file: File;
+  /**
+   * The position where the image should be inserted. If not provided, the
+   * image is inserted at the current selection.
+   */
+  pos?: number;
+  /**
+   * If the image should replace the existing image at the given position. This
+   * is only used if `pos` is provided.
+   *
+   * @default false
+   */
+  replace?: boolean;
+  /**
+   * A handler to be called when an error occurs during the upload.
+   */
+  onError?: ImageUploadErrorHandler;
+}
+/**
+ * Options for the {@link ImageUploadErrorHandler} callback.
+ */
+interface ImageUploadErrorHandlerOptions {
+  /**
+   * The file that was uploaded.
+   */
+  file: File;
+  /**
+   * The error that occurred during the upload.
+   */
+  error: unknown;
+  /**
+   * The upload task that was used to upload the file.
+   */
+  uploadTask: UploadTask<string>;
+}
+/**
+ * A handler to be called when an error occurs during the upload.
+ */
+type ImageUploadErrorHandler = (options: ImageUploadErrorHandlerOptions) => void;
+interface ImageAttrs {
+  src?: string | null;
+  width?: number | null;
+  height?: number | null;
+}
+/**
+ * @internal
+ */
+type ImageSpecExtension = Extension$1<{
+  Nodes: {
+    image: ImageAttrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type ImageCommandsExtension = Extension$1<{
+  Commands: {
+    insertImage: [attrs?: ImageAttrs];
+    uploadImage: [options: UploadImageOptions];
+  };
+}>;
+/**
+ * @internal
+ */
+type ImageExtension$1 = Union<[ImageSpecExtension, ImageCommandsExtension]>;
+type HorizontalRuleCommandsExtension = Extension$1<{
+  Commands: {
+    insertHorizontalRule: [];
+  };
+}>;
+type HorizontalRuleSpecExtension = Extension$1<{
+  Nodes: {
+    horizontalRule: Attrs;
+  };
+}>;
+type HorizontalRuleExtension$1 = Union<[HorizontalRuleSpecExtension, HorizontalRuleCommandsExtension]>;
+/**
+ * @internal
+ */
+type HardBreakCommandsExtension = Extension$1<{
+  Commands: {
+    insertHardBreak: [];
+  };
+}>;
+/**
+ * @internal
+ */
+type HardBreakSpecExtension = Extension$1<{
+  Nodes: {
+    hardBreak: Attrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type HardBreakExtension$1 = Union<[HardBreakSpecExtension, HardBreakCommandsExtension]>;
+/**
+ * Options for moveTableRow
+ *
+ * @public
+ */
+interface MoveTableRowOptions {
+  /**
+   * The source row index to move from.
+   */
+  from: number;
+  /**
+   * The destination row index to move to.
+   */
+  to: number;
+  /**
+   * Whether to select the moved row after the operation.
+   *
+   * @default true
+   */
+  select?: boolean;
+  /**
+   * Optional position to resolve table from. If not provided, uses the current selection.
+   */
+  pos?: number;
+}
+/**
+ * Options for moveTableColumn
+ *
+ * @public
+ */
+interface MoveTableColumnOptions {
+  /**
+   * The source column index to move from.
+   */
+  from: number;
+  /**
+   * The destination column index to move to.
+   */
+  to: number;
+  /**
+   * Whether to select the moved column after the operation.
+   *
+   * @default true
+   */
+  select?: boolean;
+  /**
+   * Optional position to resolve table from. If not provided, uses the current selection.
+   */
+  pos?: number;
+}
+interface InsertTableOptions {
+  /**
+   * The number of rows in the table.
+   */
+  row: number;
+  /**
+   * The number of columns in the table.
+   */
+  col: number;
+  /**
+   * Whether the table has a header row.
+   *
+   * @default false
+   */
+  header?: boolean;
+}
+interface SelectTableCellOptions {
+  /**
+   * A hit position of the table cell to select from. By default, the selection
+   * anchor will be used.
+   */
+  pos?: number;
+}
+interface SelectTableColumnOptions {
+  /**
+   * A hit position of the table cell to select from. By default, the selection
+   * anchor will be used.
+   */
+  anchor?: number;
+  /**
+   * A hit position of the table cell to select to. By default, the selection
+   * head will be used.
+   */
+  head?: number;
+}
+interface SelectTableRowOptions {
+  /**
+   * A hit position of the table cell to select from. By default, the selection
+   * anchor will be used.
+   */
+  anchor?: number;
+  /**
+   * A hit position of the table cell to select to. By default, the selection
+   * head will be used.
+   */
+  head?: number;
+}
+interface SelectTableOptions {
+  /**
+   * A hit position of the table to select from. By default, the selection
+   * anchor will be used.
+   */
+  pos?: number;
+}
+/**
+ * @internal
+ */
+type TableCommandsExtension = Extension$1<{
+  Commands: {
+    insertTable: [options: InsertTableOptions];
+    exitTable: [];
+    selectTable: [options?: SelectTableOptions];
+    selectTableCell: [options?: SelectTableCellOptions];
+    selectTableColumn: [options?: SelectTableColumnOptions];
+    selectTableRow: [options?: SelectTableRowOptions];
+    addTableColumnBefore: [];
+    addTableColumnAfter: [];
+    addTableRowAbove: [];
+    addTableRowBelow: [];
+    deleteTable: [];
+    deleteTableColumn: [];
+    deleteTableRow: [];
+    deleteCellSelection: [];
+    mergeTableCells: [];
+    splitTableCell: [];
+    moveTableRow: [options: MoveTableRowOptions];
+    moveTableColumn: [options: MoveTableColumnOptions];
+  };
+}>;
+interface CellAttrs {
+  colspan?: number;
+  rowspan?: number;
+  colwidth?: number[] | null;
+}
+/**
+ * @internal
+ */
+type TableSpecExtension = Extension$1<{
+  Nodes: {
+    table: Attrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type TableRowSpecExtension = Extension$1<{
+  Nodes: {
+    tableRow: Attrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type TableCellSpecExtension = Extension$1<{
+  Nodes: {
+    tableCell: CellAttrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type TableHeaderCellSpecExtension = Extension$1<{
+  Nodes: {
+    tableHeaderCell: CellAttrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type TableExtension$1 = Union<[TableSpecExtension, TableRowSpecExtension, TableCellSpecExtension, TableHeaderCellSpecExtension, TableCommandsExtension]>;
+/**
+ * The attributes for the `codeBlock` node.
+ */
+interface CodeBlockAttrs {
+  language: string;
+}
+/**
+ * @internal
+ */
+type CodeBlockCommandsExtension = Extension$1<{
+  Commands: {
+    setCodeBlock: [attrs?: CodeBlockAttrs];
+    insertCodeBlock: [attrs?: CodeBlockAttrs];
+    toggleCodeBlock: [attrs?: CodeBlockAttrs];
+    setCodeBlockAttrs: [attrs: CodeBlockAttrs];
+  };
+}>;
+/**
+ * @internal
+ */
+type CodeBlockSpecExtension = Extension$1<{
+  Nodes: {
+    codeBlock: CodeBlockAttrs;
+  };
+}>;
+/**
+ * @internal
+ */
+type CodeBlockExtension$1 = Union<[CodeBlockSpecExtension, CodeBlockCommandsExtension]>;
+/**
+ * The interaction tail every editor wants and no document shape depends on:
+ * the base keymap, the base commands, undo/redo history, the gap cursor, the
+ * virtual selection and mod-click prevention.
+ *
+ * None of these registers a node or a mark, so including them changes nothing
+ * about what a derived wire schema accepts — which is why compiling a schema
+ * for validation alone can include them without consequence, and why they are
+ * a separate export rather than baked into the node lists.
+ */
+export declare function defineEditorBehaviour(): Union<readonly [PlainExtension, BaseCommandsExtension, HistoryExtension, PlainExtension, PlainExtension, PlainExtension]>;
+/**
+ * The block-document grammar: a `block+` top node, text, ProseKit's stock
+ * block set (paragraph, heading, list, blockquote, image, horizontal rule,
+ * hard break, table, code block), {@link defineStandardMarks} and
+ * {@link defineEditorBehaviour}, plus whatever `extra` extensions the caller
+ * composes in.
+ */
+export declare function defineBlockDocumentExtension(...extra: ReadonlyArray<Extension>): Union<readonly [DocExtension$1, TextExtension$1, ParagraphExtension$1, HeadingExtension$1, ListExtension$1, BlockquoteExtension$1, ImageExtension$1, HorizontalRuleExtension$1, HardBreakExtension$1, TableExtension$1, CodeBlockExtension$1, Union<readonly [BoldExtension$1, ItalicExtension$1, UnderlineExtension$1, StrikeExtension$1, CodeExtension$1, LinkExtension$1, Extension<{
+  Marks: {
+    highlight: Attrs$1;
+  };
+}>, Extension<{
+  Marks: {
+    subscript: Attrs$1;
+  };
+}>, Extension<{
+  Marks: {
+    superscript: Attrs$1;
+  };
+}>]>, Union<readonly [PlainExtension, BaseCommandsExtension, HistoryExtension, PlainExtension, PlainExtension, PlainExtension]>, ...Extension<ExtensionTyping<any, any, any>>[]]>;
+/** The extension {@link defineBlockDocumentExtension} returns with no extras. */
+type BlockDocumentExtension = ReturnType<typeof defineBlockDocumentExtension>;
+/**
+ * The inline-document grammar: an `inline*` top node
+ * ({@link defineInlineDoc}), text, {@link defineStandardMarks} and
+ * {@link defineEditorBehaviour}, plus whatever `extra` extensions the caller
+ * composes in.
+ *
+ * No block node is registered at all, so a paragraph is not merely
+ * unreachable from the toolbar — it fails to decode.
+ */
+export declare function defineInlineDocumentExtension(...extra: ReadonlyArray<Extension>): Union<readonly [Extension<{
+  Nodes: {
+    doc: Attrs$1;
+  };
+}>, TextExtension$1, Union<readonly [BoldExtension$1, ItalicExtension$1, UnderlineExtension$1, StrikeExtension$1, CodeExtension$1, LinkExtension$1, Extension<{
+  Marks: {
+    highlight: Attrs$1;
+  };
+}>, Extension<{
+  Marks: {
+    subscript: Attrs$1;
+  };
+}>, Extension<{
+  Marks: {
+    superscript: Attrs$1;
+  };
+}>]>, Union<readonly [PlainExtension, BaseCommandsExtension, HistoryExtension, PlainExtension, PlainExtension, PlainExtension]>, ...Extension<ExtensionTyping<any, any, any>>[]]>;
+/** The extension {@link defineInlineDocumentExtension} returns with no extras. */
+type InlineDocumentExtension = ReturnType<typeof defineInlineDocumentExtension>;
+export { type AttributeOverrides, type BlockDocumentExtension, type BlockquoteExtension, type BoldExtension, type CodeBlockExtension, type CodeExtension, type DocExtension, type DocumentSchema, type DocumentSchemaOptions, type HardBreakExtension, type HeadingExtension, type HorizontalRuleExtension, type HtmlRenderer, type HtmlRendererOptions, type ImageExtension, type InlineDocumentExtension, type ItalicExtension, type LinkExtension, type ListExtension, type ParagraphExtension, type StrikeExtension, type TableExtension, type TextExtension, type UnderlineExtension, defineBlockquote, defineBold, defineCode, defineCodeBlock, defineDoc, defineHardBreak, defineHeading, defineHorizontalRule, defineImage, defineItalic, defineLink, defineList, defineParagraph, defineStrike, defineTable, defineText, defineUnderline };