@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/model/schema.d.ts

@@ -0,0 +1,740 @@
+import { ContentInput, ContentMatch, SpecRefs } from "./content.js";
+import { ParseRule, TagParseRule } from "./from_dom.js";
+import { DOMOutputSpec } from "./to_dom.js";
+import "./dom.js";
+import { AttributeError, ContentError, JSONError, ModelError, SchemaDefinitionError } from "./errors.js";
+import { Fragment } from "./fragment.js";
+import { Mark } from "./mark.js";
+import { Node, TextNode } from "./node.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as S from "effect/Schema";
+/**
+ * Describes a single attribute of a node or mark type.
+ *
+ * - `schema` is an Effect `Schema` used to validate the value and to
+ *   decode/encode it from/to JSON. It also gives the attribute its
+ *   static type.
+ * - `default` is used when no value is provided. Attributes without a
+ *   default are required.
+ * - `validate` is accepted for ProseMirror compatibility: either a
+ *   `|`-separated list of primitive type names or a function that
+ *   throws on invalid values.
+ *
+ * Supplied values are validated whenever a node or mark is created (as
+ * prosemirror-model does since 1.25.12), and again by `Node.check`;
+ * defaults are trusted. A `schema` or a type-name `validate` rejects a
+ * value with an `AttributeError`; a `validate` function's own exception
+ * propagates as thrown (a defect in the Effect API).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface AttributeSpec<A = any, I = any> {
+  readonly schema?: S.Codec<A, I> | undefined;
+  readonly default?: A;
+  readonly validate?: string | ((value: unknown) => void) | undefined;
+}
+/**
+ * An attribute is either described by an `AttributeSpec` or, as a
+ * shorthand for a required attribute, directly by an Effect `Schema`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type AttributeDefinition = S.Top | AttributeSpec;
+/**
+ * @since 0.1.0
+ * @category models
+ */
+export interface AttributeDefinitions {
+  readonly [name: string]: AttributeDefinition;
+}
+/**
+ * A description of a node type, used when defining a schema.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface NodeSpec {
+  /**
+   * The content expression for this node. When not given, the node
+   * does not allow any content. Prefer `Content` combinators, which
+   * keep the allowed child types at the type level; a plain string is
+   * read as ProseMirror content syntax (`"paragraph block*"`), and is
+   * only precisely typed when it is a single bare name.
+   */
+  readonly content?: ContentInput<string> | undefined;
+  /**
+   * 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.
+   */
+  readonly marks?: string | undefined;
+  /** The group or space-separated groups to which this node belongs. */
+  readonly group?: string | undefined;
+  /** Should be set to true for inline nodes. (Implied for text nodes.) */
+  readonly inline?: boolean | undefined;
+  /**
+   * Can be set to true to indicate that, though this isn't a leaf node,
+   * it doesn't have directly editable content and should be treated as
+   * a single unit in the view.
+   */
+  readonly atom?: boolean | undefined;
+  /** The attributes that nodes of this type get. */
+  readonly attrs?: AttributeDefinitions | undefined;
+  /** Whether nodes of this type can be selected as a node selection. */
+  readonly selectable?: boolean | undefined;
+  /** Whether nodes of this type can be dragged without being selected. */
+  readonly draggable?: boolean | undefined;
+  /** Indicates that this node contains code. */
+  readonly code?: boolean | undefined;
+  /** Controls the way whitespace in this node is parsed. */
+  readonly whitespace?: "pre" | "normal" | undefined;
+  /** Whether this node is considered an important parent during replace operations. */
+  readonly definingAsContext?: boolean | undefined;
+  /** Whether defining parents of inserted content are preserved. */
+  readonly definingForContent?: boolean | undefined;
+  /** Enables both `definingAsContext` and `definingForContent`. */
+  readonly defining?: boolean | undefined;
+  /** Whether the sides of nodes of this type count as editing boundaries. */
+  readonly isolating?: boolean | undefined;
+  /** Defines the default way a node of this type should be serialized to DOM/HTML. */
+  readonly toDOM?: ((node: Node<any, any>) => DOMOutputSpec) | undefined;
+  /** DOM parser rules for this node type. */
+  readonly parseDOM?: ReadonlyArray<TagParseRule> | undefined;
+  /** Defines the way a node of this type is rendered for debugging. */
+  readonly toDebugString?: ((node: Node<any, any>) => string) | undefined;
+  /** Defines the way a leaf node of this type is serialized to a string. */
+  readonly leafText?: ((node: Node<any, any>) => string) | undefined;
+  /** Marks this (inline leaf) node as the schema's linebreak equivalent. */
+  readonly linebreakReplacement?: boolean | undefined;
+  /** Node specs may include arbitrary extra properties. */
+  readonly [key: string]: unknown;
+}
+/**
+ * Used to define marks when creating a schema.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface MarkSpec {
+  /** The attributes that marks of this type get. */
+  readonly attrs?: AttributeDefinitions | undefined;
+  /** Whether this mark should be active when the cursor is positioned at its end. Defaults to true. */
+  readonly inclusive?: boolean | undefined;
+  /** Space-separated mark names or groups this mark excludes. */
+  readonly excludes?: string | undefined;
+  /** The group or space-separated groups to which this mark belongs. */
+  readonly group?: string | undefined;
+  /** Whether marks of this type can span multiple adjacent nodes when serialized. Defaults to true. */
+  readonly spanning?: boolean | undefined;
+  /** Marks the content of this span as being code. */
+  readonly code?: boolean | undefined;
+  /** Defines the default way marks of this type should be serialized to DOM/HTML. */
+  readonly toDOM?: ((mark: Mark<any, any>, inline: boolean) => DOMOutputSpec) | undefined;
+  /** DOM parser rules for this mark type. */
+  readonly parseDOM?: ReadonlyArray<ParseRule> | undefined;
+  /** Mark specs may include arbitrary extra properties. */
+  readonly [key: string]: unknown;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+export interface NodeSpecs {
+  readonly [name: string]: NodeSpec;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+export interface MarkSpecs {
+  readonly [name: string]: MarkSpec;
+}
+/**
+ * An object describing a schema, as passed to `DocSchema.make`.
+ *
+ * The order of `nodes` and `marks` is significant: it determines which
+ * parse rules take precedence by default, which nodes come first in a
+ * given group, and the order of marks in mark sets.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface SchemaSpec<N extends NodeSpecs = NodeSpecs, M extends MarkSpecs = MarkSpecs, Top extends string = string> {
+  readonly nodes: N;
+  readonly marks?: M | undefined;
+  /** The name of the default top-level node. Defaults to `"doc"`. */
+  readonly topNode?: Top | undefined;
+}
+/**
+ * A schema of unknown shape.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type AnySchema = DocSchema<any, any>;
+/**
+ * The node specs of a schema.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type NodeSpecsOf<Sc> = Sc extends DocSchema<infer N, any> ? N : never;
+/**
+ * The mark specs of a schema.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type MarkSpecsOf<Sc> = Sc extends DocSchema<any, infer M> ? M : never;
+/**
+ * The names of a schema's node types.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type NodeNames<Sc> = keyof NodeSpecsOf<Sc> & string;
+/**
+ * The names of a schema's mark types.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type MarkNames<Sc> = keyof MarkSpecsOf<Sc> & string;
+/**
+ * The spec of node type `N` in schema `Sc`.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type NodeSpecOf<Sc, N extends string> = NodeSpecsOf<Sc> extends (infer Specs) ? (N extends keyof Specs ? Specs[N] : NodeSpec) : NodeSpec;
+/**
+ * The spec of mark type `M` in schema `Sc`.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type MarkSpecOf<Sc, M extends string> = MarkSpecsOf<Sc> extends (infer Specs) ? (M extends keyof Specs ? Specs[M] : MarkSpec) : MarkSpec;
+type Split<Str extends string> = string extends Str ? string : Str extends `${infer H} ${infer T}` ? (H extends "" ? never : H) | Split<T> : Str extends "" ? never : Str;
+/**
+ * The groups a spec belongs to.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type GroupsOf<Spec> = Spec extends {
+  readonly group: infer G extends string;
+} ? Split<G> : never;
+/**
+ * The names (of nodes or groups) referenced in a spec's content
+ * expression.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type ContentRefsOf<Spec> = Spec extends {
+  readonly content: infer C;
+} ? SpecRefs<C> : never;
+/**
+ * The names of the node types that can appear as children of node type
+ * `N` in schema `Sc`.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type ChildNames<Sc, N extends string> = string extends NodeNames<Sc> ? string : string extends N ? NodeNames<Sc> : ResolveRefs<Sc, ContentRefsOf<NodeSpecOf<Sc, N>>>;
+/**
+ * Resolve a set of node/group names to the node names they denote.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type ResolveRefs<Sc, R extends string> = string extends R ? NodeNames<Sc> : { [C in NodeNames<Sc>]: C extends R ? C : [GroupsOf<NodeSpecOf<Sc, C>> & R] extends [never] ? never : C; }[NodeNames<Sc>];
+/**
+ * The names of node types in schema `Sc` that belong to group `G`.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type NodesInGroup<Sc, G extends string> = ResolveRefs<Sc, G>;
+/**
+ * The names of all mark types in group `G` of schema `Sc`.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type MarksInGroup<Sc, G extends string> = string extends MarkNames<Sc> ? string : { [C in MarkNames<Sc>]: C extends G ? C : [GroupsOf<MarkSpecOf<Sc, C>> & G] extends [never] ? never : C; }[MarkNames<Sc>];
+type Widen<A> = A extends string ? string : A extends number ? number : A extends boolean ? boolean : A extends null | undefined ? unknown : A;
+interface ValidateTypeNames {
+  readonly string: string;
+  readonly number: number;
+  readonly boolean: boolean;
+  readonly bigint: bigint;
+  readonly symbol: symbol;
+  readonly undefined: undefined;
+  readonly object: object;
+  readonly function: (...args: ReadonlyArray<never>) => void;
+  readonly null: null;
+}
+type SplitBar<V extends string> = V extends `${infer H}|${infer T}` ? H | SplitBar<T> : V;
+type ValidateType<V extends string> = string extends V ? unknown : SplitBar<V> extends (infer K) ? K extends keyof ValidateTypeNames ? ValidateTypeNames[K] : never : never;
+/**
+ * The value type of an attribute definition: its `schema`'s type; else
+ * the types its `validate` type names admit (`"string|null"` is
+ * `string | null`); else the widened type of its `default`. An attribute
+ * with none of these (a ProseMirror-style `{ default: null }`, or a
+ * `validate` function) is `unknown`: nothing says what it holds.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type AttributeType<D> = D extends S.Top ? D["Type"] : D extends {
+  readonly schema: infer Sc extends S.Top;
+} ? Sc["Type"] : D extends {
+  readonly validate: infer V extends string;
+} ? ValidateType<V> : D extends {
+  readonly default: infer A;
+} ? Widen<A> : unknown;
+type AttrDefsOf<Spec> = Spec extends {
+  readonly attrs: infer A extends AttributeDefinitions;
+} ? A : {};
+/**
+ * The (complete) attributes object for a node or mark spec.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type AttrsOfSpec<Spec> = [Spec] extends [never] ? Attrs : string extends keyof AttrDefsOf<Spec> ? Attrs : { readonly [K in keyof AttrDefsOf<Spec>]: AttributeType<AttrDefsOf<Spec>[K]>; };
+type OptionalAttrKeys<D> = { [K in keyof D]: D[K] extends {
+  readonly default?: any;
+} ? K : never; }[keyof D];
+/**
+ * The attributes accepted when creating a node or mark from a spec:
+ * attributes with defaults may be omitted.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type AttrsInputOfSpec<Spec> = [Spec] extends [never] ? Attrs : string extends keyof AttrDefsOf<Spec> ? Attrs : Simplify<{ readonly [K in Exclude<keyof AttrDefsOf<Spec>, OptionalAttrKeys<AttrDefsOf<Spec>>>]: AttributeType<AttrDefsOf<Spec>[K]>; } & { readonly [K in OptionalAttrKeys<AttrDefsOf<Spec>>]?: AttributeType<AttrDefsOf<Spec>[K]>; }>;
+type Simplify<A> = { [K in keyof A]: A[K]; } & {};
+/**
+ * The attributes of node type `N` in schema `Sc`.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type NodeAttrs<Sc, N extends string> = string extends NodeNames<Sc> ? Attrs : N extends any ? AttrsOfSpec<NodeSpecOf<Sc, N>> : never;
+/**
+ * The attributes accepted when creating a node of type `N`.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type NodeAttrsInput<Sc, N extends string> = string extends NodeNames<Sc> ? Attrs : AttrsInputOfSpec<NodeSpecOf<Sc, N>>;
+/**
+ * The attributes of mark type `M` in schema `Sc`.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type MarkAttrs<Sc, M extends string> = string extends MarkNames<Sc> ? Attrs : M extends any ? AttrsOfSpec<MarkSpecOf<Sc, M>> : never;
+/**
+ * The attributes accepted when creating a mark of type `M`.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type MarkAttrsInput<Sc, M extends string> = string extends MarkNames<Sc> ? Attrs : AttrsInputOfSpec<MarkSpecOf<Sc, M>>;
+/**
+ * True when all attributes of the spec have defaults (or there are
+ * none), meaning the attrs argument can be omitted.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type AttrsOptional<Spec> = {} extends AttrsInputOfSpec<Spec> ? true : false;
+type GroupNames<Specs> = { [K in keyof Specs]: GroupsOf<Specs[K]>; }[keyof Specs];
+type UnknownRefs<Refs, Known> = string extends Refs ? never : Exclude<Refs, Known>;
+type MarkExprRefs<Spec, Key extends string> = Spec extends { readonly [P in Key]: infer E extends string; } ? Split<E> : never;
+type Fail<Bad, Message extends string> = [Bad] extends [never] ? unknown : { readonly [P in Message]: true; };
+type BadDefaults<Defs> = { [K in keyof Defs]: Defs[K] extends {
+  readonly schema: infer Sch extends S.Top;
+  readonly default: infer D;
+} ? [D] extends [Sch["Type"]] ? never : K : never; }[keyof Defs] & string;
+type BadDefaultsOf<Spec> = BadDefaults<AttrDefsOf<Spec>>;
+type BadValidateNames<Defs> = { [K in keyof Defs]: Defs[K] extends {
+  readonly validate: infer V extends string;
+} ? string extends V ? never : Exclude<SplitBar<V>, keyof ValidateTypeNames> : never; }[keyof Defs] & string;
+type BadValidateNamesOf<Spec> = BadValidateNames<AttrDefsOf<Spec>>;
+type MarkRefNames<M> = (keyof M & string) | GroupNames<M> | "_";
+type UnknownContent<N, K extends keyof N> = UnknownRefs<ContentRefsOf<N[K]>, (keyof N & string) | GroupNames<N>> & string;
+type UnknownMarks<M, Spec, Key extends string> = UnknownRefs<MarkExprRefs<Spec, Key>, MarkRefNames<M>> & string;
+type NodeSpecCheck<N, M, K extends keyof N> = Fail<UnknownContent<N, K>, `Unknown node type or group in content: ${UnknownContent<N, K>}`> & Fail<UnknownMarks<M, N[K], "marks">, `Unknown mark type or group in marks: ${UnknownMarks<M, N[K], "marks">}`> & Fail<BadDefaultsOf<N[K]>, `Attribute default is not a value of its schema: ${BadDefaultsOf<N[K]>}`> & Fail<BadValidateNamesOf<N[K]>, `Unknown type name in validate: ${BadValidateNamesOf<N[K]>}`>;
+type MarkSpecCheck<M, K extends keyof M> = Fail<UnknownMarks<M, M[K], "excludes">, `Unknown mark type or group in excludes: ${UnknownMarks<M, M[K], "excludes">}`> & Fail<BadDefaultsOf<M[K]>, `Attribute default is not a value of its schema: ${BadDefaultsOf<M[K]>}`> & Fail<BadValidateNamesOf<M[K]>, `Unknown type name in validate: ${BadValidateNamesOf<M[K]>}`>;
+/**
+ * The static checks `DocSchema.make` applies to a spec, on top of its
+ * type: every name a content expression, a `marks` expression or an
+ * `excludes` refers to exists; the top node and a `text` node exist; no
+ * name is both a node and a mark; every attribute `default` is a value
+ * of the attribute's `schema`; and every `validate` type name is one the
+ * runtime knows. These are the runtime
+ * `SchemaDefinitionError`s, reported where the spec is written. Each check
+ * applies only where the names are known statically: a ProseMirror
+ * content string with operators, or an untyped spec, is left to the
+ * runtime check.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type SchemaSpecCheck<N, M, Top extends string> = string extends keyof N ? unknown : {
+  readonly nodes: { readonly [K in keyof N]: NodeSpecCheck<N, M, K>; } & { readonly [K in (string extends Top ? never : Top) | "text"]: NodeSpec; };
+} & (string extends keyof M ? unknown : {
+  readonly marks?: { readonly [K in keyof M]: MarkSpecCheck<M, K>; } & { readonly [K in keyof M & keyof N]: Fail<K, `Name used by both a node and a mark: ${K & string}`>; };
+});
+/**
+ * The node types of schema `Sc` whose attributes all have defaults (or
+ * that have none), so their constructors may be called without an
+ * attributes object. For other types, the attributes are a required
+ * argument, so a required attribute cannot be left out by omitting the
+ * whole object.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type NodesWithOptionalAttrs<Sc> = { [K in NodeNames<Sc>]: Partial<NodeAttrsInput<Sc, K>> extends NodeAttrsInput<Sc, K> ? K : never; }[NodeNames<Sc>];
+/**
+ * The mark types of schema `Sc` whose attributes all have defaults (see
+ * `NodesWithOptionalAttrs`).
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type MarksWithOptionalAttrs<Sc> = { [K in MarkNames<Sc>]: Partial<MarkAttrsInput<Sc, K>> extends MarkAttrsInput<Sc, K> ? K : never; }[MarkNames<Sc>];
+/**
+ * An untyped attributes object.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Attrs = {
+  readonly [attr: string]: any;
+};
+/**
+ * The marks given to a node constructor: a mark set, or nothing (`null`
+ * or `undefined`) for none.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type MarksInput<Sc extends AnySchema = AnySchema> = ReadonlyArray<Mark<Sc>> | null | undefined;
+/**
+ * Anything that can be converted to a fragment of `N` nodes.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type FragmentInput<Sc extends AnySchema = AnySchema, N extends string = string> = Fragment<Sc, N> | Node<Sc, N> | ReadonlyArray<Node<Sc, N>> | null | undefined;
+/** @internal */
+export declare class Attribute {
+  readonly hasDefault: boolean;
+  readonly default: unknown;
+  readonly schema: S.Codec<any, any> | undefined;
+  readonly validate: ((value: unknown) => void) | undefined;
+  readonly is: ((value: unknown) => boolean) | undefined;
+  readonly identityCodec: boolean;
+  constructor(typeName: string, attrName: string, definition: AttributeDefinition);
+  get isRequired(): boolean;
+}
+/** @internal */
+export declare function computeAttrs(attrs: Record<string, Attribute>, value: Attrs | null | undefined, type: string, typeName: string, decoded?: boolean): Attrs;
+/** @internal */
+export declare function checkAttrs(attrs: Record<string, Attribute>, values: Attrs, type: string, typeName: string): void;
+/**
+ * Node types are objects allocated once per schema and used to tag
+ * `Node` instances. They contain information about the node type, such
+ * as its name and what kind of node it represents.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class NodeType<Sc extends AnySchema = AnySchema, out N extends NodeNames<Sc> = NodeNames<Sc>> {
+  /** The name the node type has in this schema. */
+  readonly name: N;
+  /** A link back to the schema the node type belongs to. */
+  readonly schema: Sc;
+  /** The spec that this type is based on. */
+  readonly spec: NodeSpecOf<Sc, N> & NodeSpec;
+  /** @internal */
+  readonly groups: ReadonlyArray<string>;
+  /** @internal */
+  readonly attrs: Record<string, Attribute>;
+  /** @internal */
+  readonly defaultAttrs: Attrs | null;
+  /** @internal Every attribute's codec is the identity: JSON attrs are the attrs. */
+  readonly identityAttrs: boolean;
+  /** True if this is a block type. */
+  readonly isBlock: boolean;
+  /** True if this is the text node type. */
+  readonly isText: boolean;
+  /** True if this node type has inline content. */
+  inlineContent: 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: ReadonlyArray<MarkType<Sc>> | null;
+  /** @internal */
+  constructor(
+  /** The name the node type has in this schema. */
+  name: N,
+  /** A link back to the schema the node type belongs to. */
+  schema: Sc,
+  /** The spec that this type is based on. */
+  spec: NodeSpecOf<Sc, N> & NodeSpec);
+  /** 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. */
+  isInGroup(group: string): boolean;
+  /** The node type's 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<any, any>): boolean;
+  /** @internal */
+  computeAttrs(attrs: Attrs | null | undefined): Attrs;
+  /**
+   * Create a node of this type. Attributes are extended with defaults,
+   * and supplied attribute values are validated (see `AttributeSpec`);
+   * content is not checked against the content expression (see
+   * `createChecked`).
+   */
+  create(this: NodeType<Sc, NodesWithOptionalAttrs<Sc>>, attrs?: NodeAttrsInput<Sc, N> | null, content?: FragmentInput<Sc, ChildNames<Sc, N>>, marks?: MarksInput<Sc>): Effect.Effect<Node<Sc, N>, AttributeError | ContentError>;
+  create(attrs: NodeAttrsInput<Sc, N>, content?: FragmentInput<Sc, ChildNames<Sc, N>>, marks?: MarksInput<Sc>): Effect.Effect<Node<Sc, N>, AttributeError | ContentError>;
+  /** Like `create`, but throws an `AttributeError` on failure. */
+  createUnsafe(this: NodeType<Sc, NodesWithOptionalAttrs<Sc>>, attrs?: NodeAttrsInput<Sc, N> | null, content?: FragmentInput<Sc, ChildNames<Sc, N>>, marks?: MarksInput<Sc>): Node<Sc, N>;
+  createUnsafe(attrs: NodeAttrsInput<Sc, N>, content?: FragmentInput<Sc, ChildNames<Sc, N>>, marks?: MarksInput<Sc>): Node<Sc, N>;
+  /**
+   * Like `createUnsafe`, for attributes already decoded by their Schemas.
+   *
+   * @internal
+   */
+  createDecodedUnsafe(attrs: Option.Option<Attrs>, content: Fragment<Sc>, marks: ReadonlyArray<Mark<Sc>>): Node<Sc, N>;
+  private computeDecodedAttrs;
+  /**
+   * Like `create`, but check the given content against the node type's
+   * content restrictions.
+   */
+  createChecked(this: NodeType<Sc, NodesWithOptionalAttrs<Sc>>, attrs?: NodeAttrsInput<Sc, N> | null, content?: FragmentInput<Sc, ChildNames<Sc, N>>, marks?: MarksInput<Sc>): Effect.Effect<Node<Sc, N>, AttributeError | ContentError>;
+  createChecked(attrs: NodeAttrsInput<Sc, N>, content?: FragmentInput<Sc, ChildNames<Sc, N>>, marks?: MarksInput<Sc>): Effect.Effect<Node<Sc, N>, AttributeError | ContentError>;
+  /** Like `createChecked`, but throws on failure. */
+  createCheckedUnsafe(this: NodeType<Sc, NodesWithOptionalAttrs<Sc>>, attrs?: NodeAttrsInput<Sc, N> | null, content?: FragmentInput<Sc, ChildNames<Sc, N>>, marks?: MarksInput<Sc>): Node<Sc, N>;
+  createCheckedUnsafe(attrs: NodeAttrsInput<Sc, N>, content?: FragmentInput<Sc, ChildNames<Sc, N>>, marks?: MarksInput<Sc>): Node<Sc, N>;
+  /**
+   * Like `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. Fails with a
+   * `ContentError` if no fitting wrapping can be found. Note that, due
+   * to the fact that required nodes can always be created, this will
+   * always succeed if you pass no content.
+   */
+  createAndFill(this: NodeType<Sc, NodesWithOptionalAttrs<Sc>>, attrs?: NodeAttrsInput<Sc, N> | null, content?: FragmentInput<Sc, ChildNames<Sc, N>>, marks?: MarksInput<Sc>): Effect.Effect<Node<Sc, N>, AttributeError | ContentError>;
+  createAndFill(attrs: NodeAttrsInput<Sc, N>, content?: FragmentInput<Sc, ChildNames<Sc, N>>, marks?: MarksInput<Sc>): Effect.Effect<Node<Sc, N>, AttributeError | ContentError>;
+  /** @internal */
+  createAndFillOrNull(attrs?: Attrs | null, content?: FragmentInput<any, any>, marks?: ReadonlyArray<Mark<any>> | null): Node<Sc, N> | null;
+  /** Returns true if the given fragment is valid content for this node type. */
+  validContent(content: Fragment<any, any>): boolean;
+  /** @internal */
+  checkContent(content: Fragment<any, any>): void;
+  /** @internal */
+  checkAttrs(attrs: Attrs): void;
+  /** Check whether the given mark type is allowed in this node. */
+  allowsMarkType(markType: MarkType<any, any>): boolean;
+  /** Test whether the given set of marks are allowed in this node. */
+  allowsMarks(marks: ReadonlyArray<Mark<any>>): boolean;
+  /** Removes the marks that are not allowed in this node from the given set. */
+  allowedMarks<M extends Mark<any>>(marks: ReadonlyArray<M>): ReadonlyArray<M>;
+  /** @internal */
+  toString(): string;
+}
+/**
+ * Like nodes, marks are tagged with type objects, which are
+ * instantiated once per schema.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class MarkType<Sc extends AnySchema = AnySchema, out M extends MarkNames<Sc> = MarkNames<Sc>> {
+  /** The name of the mark type. */
+  readonly name: M;
+  /** @internal */
+  readonly rank: number;
+  /** The schema that this mark type instance is part of. */
+  readonly schema: Sc;
+  /** The spec on which the type is based. */
+  readonly spec: MarkSpecOf<Sc, M> & MarkSpec;
+  /** @internal */
+  readonly attrs: Record<string, Attribute>;
+  /** @internal Every attribute's codec is the identity: JSON attrs are the attrs. */
+  readonly identityAttrs: boolean;
+  /** @internal */
+  excluded: ReadonlyArray<MarkType<Sc>>;
+  /** @internal */
+  readonly instance: Option.Option<Mark<Sc, M>>;
+  /** @internal */
+  constructor(
+  /** The name of the mark type. */
+  name: M,
+  /** @internal */
+  rank: number,
+  /** The schema that this mark type instance is part of. */
+  schema: Sc,
+  /** The spec on which the type is based. */
+  spec: MarkSpecOf<Sc, M> & MarkSpec);
+  /**
+   * Create a mark of this type. Attributes that are not given are
+   * filled in from their defaults; supplied values are validated (see
+   * `AttributeSpec`).
+   */
+  create(this: MarkType<Sc, MarksWithOptionalAttrs<Sc>>, attrs?: MarkAttrsInput<Sc, M>): Effect.Effect<Mark<Sc, M>, AttributeError>;
+  create(attrs: MarkAttrsInput<Sc, M>): Effect.Effect<Mark<Sc, M>, AttributeError>;
+  /** Like `create`, but throws an `AttributeError` on failure. */
+  createUnsafe(this: MarkType<Sc, MarksWithOptionalAttrs<Sc>>, attrs?: MarkAttrsInput<Sc, M>): Mark<Sc, M>;
+  createUnsafe(attrs: MarkAttrsInput<Sc, M>): Mark<Sc, M>;
+  /**
+   * Like `createUnsafe`, for attributes already decoded by their Schemas.
+   *
+   * @internal
+   */
+  createDecodedUnsafe(attrs: Option.Option<Attrs>): Mark<Sc, M>;
+  /**
+   * 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<Mk extends Mark<any>>(set: ReadonlyArray<Mk>): ReadonlyArray<Mk>;
+  /** Find a mark of this type in the given set. */
+  isInSet(set: ReadonlyArray<Mark<any>>): Option.Option<Mark<Sc, M>>;
+  /** @internal */
+  findInSet(set: ReadonlyArray<Mark<any>>): Mark<Sc, M> | undefined;
+  /** @internal */
+  checkAttrs(attrs: Attrs): void;
+  /** Queries whether a given mark type is excluded by this one. */
+  excludes(other: MarkType<any, any>): boolean;
+  /** @internal */
+  toString(): string;
+}
+type NodeTypes<Sc extends AnySchema, N extends NodeSpecs> = { readonly [K in keyof N & string]: NodeType<Sc, K>; };
+type MarkTypes<Sc extends AnySchema, M extends MarkSpecs> = { readonly [K in keyof M & string]: MarkType<Sc, K>; };
+/**
+ * A document schema. Holds node and mark type objects for the nodes and
+ * marks that may occur in conforming documents, and provides
+ * functionality for creating and deserializing such documents.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class DocSchema<N extends NodeSpecs = NodeSpecs, M extends MarkSpecs = MarkSpecs> {
+  /** The spec on which the schema is based. */
+  readonly spec: {
+    readonly nodes: N;
+    readonly marks: M;
+    readonly topNode?: string | undefined;
+  };
+  /** An object mapping the schema's node names to node type objects. */
+  readonly nodes: NodeTypes<DocSchema<N, M>, N> & Readonly<Partial<Record<string, NodeType<DocSchema<N, M>>>>>;
+  /** A map from mark names to mark type objects. */
+  readonly marks: MarkTypes<DocSchema<N, M>, M> & Readonly<Partial<Record<string, MarkType<DocSchema<N, M>>>>>;
+  /** The linebreak replacement node defined in this schema, if any. */
+  readonly linebreakReplacement: Option.Option<NodeType<DocSchema<N, M>>>;
+  /** The type of the default top node for this schema. */
+  readonly topNodeType: NodeType<DocSchema<N, M>>;
+  /**
+   * An object for storing whatever values modules may want to compute
+   * and cache per schema.
+   */
+  readonly cached: Record<string, unknown>;
+  /** @internal */
+  constructor(spec: SchemaSpec<N, M>);
+  /**
+   * Construct a schema from a schema specification. A spec with literal
+   * names is also checked statically (`SchemaSpecCheck`): an unknown
+   * content, `marks` or `excludes` reference, a missing top or `text`
+   * node, a name used by both a node and a mark, a `default` outside its
+   * `schema` or an unknown `validate` type name fails to compile, where the
+   * runtime would fail with a `SchemaDefinitionError`.
+   */
+  static make<const N extends NodeSpecs, const M extends MarkSpecs = {}, const Top extends string = "doc">(spec: SchemaSpec<N, M, Top> & NoInfer<SchemaSpecCheck<N, M, Top>>): Effect.Effect<DocSchema<N, M>, SchemaDefinitionError>;
+  /** Like `make`, but throws a `SchemaDefinitionError` for invalid specs. */
+  static makeUnsafe<const N extends NodeSpecs, const M extends MarkSpecs = {}, const Top extends string = "doc">(spec: SchemaSpec<N, M, Top> & NoInfer<SchemaSpecCheck<N, M, Top>>): DocSchema<N, M>;
+  /**
+   * Create a node in this schema. Attributes are extended with
+   * defaults and the content is checked against the node type's
+   * content expression.
+   */
+  node<K extends NodesWithOptionalAttrs<DocSchema<N, M>>>(type: K | NodeType<DocSchema<N, M>, K>, attrs?: NodeAttrsInput<DocSchema<N, M>, K> | null, content?: FragmentInput<DocSchema<N, M>, ChildNames<DocSchema<N, M>, K>>, marks?: MarksInput<DocSchema<N, M>>): Effect.Effect<Node<DocSchema<N, M>, K>, AttributeError | ContentError>;
+  node<K extends keyof N & string>(type: K | NodeType<DocSchema<N, M>, K>, attrs: NodeAttrsInput<DocSchema<N, M>, K>, content?: FragmentInput<DocSchema<N, M>, ChildNames<DocSchema<N, M>, K>>, marks?: MarksInput<DocSchema<N, M>>): Effect.Effect<Node<DocSchema<N, M>, K>, AttributeError | ContentError>;
+  /** Like `node`, but throws on failure. */
+  nodeUnsafe<K extends NodesWithOptionalAttrs<DocSchema<N, M>>>(type: K | NodeType<DocSchema<N, M>, K>, attrs?: NodeAttrsInput<DocSchema<N, M>, K> | null, content?: FragmentInput<DocSchema<N, M>, ChildNames<DocSchema<N, M>, K>>, marks?: MarksInput<DocSchema<N, M>>): Node<DocSchema<N, M>, K>;
+  nodeUnsafe<K extends keyof N & string>(type: K | NodeType<DocSchema<N, M>, K>, attrs: NodeAttrsInput<DocSchema<N, M>, K>, content?: FragmentInput<DocSchema<N, M>, ChildNames<DocSchema<N, M>, K>>, marks?: MarksInput<DocSchema<N, M>>): Node<DocSchema<N, M>, K>;
+  /**
+   * Create a text node in the schema. Fails for empty strings, since
+   * empty text nodes are not allowed.
+   */
+  text(text: string, marks?: MarksInput<DocSchema<N, M>>): Effect.Effect<TextNode<DocSchema<N, M>>, ContentError>;
+  /** Like `text`, but throws a `ContentError` for empty strings. */
+  textUnsafe(text: string, marks?: ReadonlyArray<Mark<DocSchema<N, M>>> | null): TextNode<DocSchema<N, M>>;
+  /** Create a mark with the given type and attributes. */
+  mark<K extends MarksWithOptionalAttrs<DocSchema<N, M>>>(type: K | MarkType<DocSchema<N, M>, K>, attrs?: MarkAttrsInput<DocSchema<N, M>, K>): Effect.Effect<Mark<DocSchema<N, M>, K>, AttributeError>;
+  mark<K extends keyof M & string>(type: K | MarkType<DocSchema<N, M>, K>, attrs: MarkAttrsInput<DocSchema<N, M>, K>): Effect.Effect<Mark<DocSchema<N, M>, K>, AttributeError>;
+  /** Like `mark`, but throws on failure. */
+  markUnsafe<K extends MarksWithOptionalAttrs<DocSchema<N, M>>>(type: K | MarkType<DocSchema<N, M>, K>, attrs?: MarkAttrsInput<DocSchema<N, M>, K>): Mark<DocSchema<N, M>, K>;
+  markUnsafe<K extends keyof M & string>(type: K | MarkType<DocSchema<N, M>, K>, attrs: MarkAttrsInput<DocSchema<N, M>, K>): Mark<DocSchema<N, M>, K>;
+  /** Deserialize a node from its JSON representation. */
+  nodeFromJSON(value: unknown): Effect.Effect<Node<DocSchema<N, M>>, JSONError | ModelError>;
+  /** Like `nodeFromJSON`, but throws on failure. */
+  nodeFromJSONUnsafe(value: unknown): Node<DocSchema<N, M>>;
+  /** Deserialize a mark from its JSON representation. */
+  markFromJSON(value: unknown): Effect.Effect<Mark<DocSchema<N, M>>, JSONError | ModelError>;
+  /** Like `markFromJSON`, but throws on failure. */
+  markFromJSONUnsafe(value: unknown): Mark<DocSchema<N, M>>;
+  /** @internal */
+  nodeType(name: string): NodeType<DocSchema<N, M>>;
+}
+/**
+ * Construct a schema from a specification.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const make: typeof DocSchema.make;
+/**
+ * Construct a schema from a specification, throwing on invalid specs.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const makeUnsafe: typeof DocSchema.makeUnsafe;
+/**
+ * Identity helper that gives a node spec's callbacks access to
+ * precisely typed attributes.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const nodeSpec: <const Spec extends NodeSpec>(spec: Spec) => Spec;
+/**
+ * Identity helper for mark specs.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const markSpec: <const Spec extends MarkSpec>(spec: Spec) => Spec;
+export {};