@voltro/cms 0.80.0 → 0.82.0

package/dist/web.d.ts

@@ -1,6 +1,10 @@
 import { ReactNode } from 'react';
+import { Row } from '@voltro/database';
 import { Schema as Schema_2 } from 'effect';
 
+/** A document's address in every language it has its own variant in. */
+export declare const alternatesOf: (trees: ReadonlyArray<LocalizedTree>, documentId: string) => ReadonlyArray<PageAlternate>;
+
 /**
  * Compute every `derivedFrom` field from its source value. Returns a NEW
  * row — the input is not mutated. A caller-provided value for a derived
@@ -9,10 +13,134 @@ import { Schema as Schema_2 } from 'effect';
  * declaration order against the progressively-updated row, so a derived
  * field may source another, earlier-declared derived field.
  */
-export declare const applyDerivations: (type: Pick<ContentType, "fields" | "derivedFields">, row: Readonly<Record<string, unknown>>) => Record<string, unknown>;
+export declare const applyDerivations: (type: Pick<ContentType, "fields" | "derivedFields"> & Partial<Pick<ContentType, "taxonomy">>, row: Readonly<Record<string, unknown>>) => Record<string, unknown>;
+
+/**
+ * The source values with each unit's target in place — what a translation
+ * draft saves. A unit without a target keeps the source text; an id that
+ * names no text in the source is ignored (see `missing` from `matchUnits`).
+ */
+export declare const applyTranslation: (fields: Readonly<Record<string, FieldSchema>>, source: Readonly<Record<string, unknown>>, units: ReadonlyArray<TranslationUnit>) => Record<string, unknown>;
+
+export declare interface Audience {
+    readonly id: string;
+    /** Raise it when the rule changes meaning; a variant records the version it was written for. */
+    readonly version: number;
+    readonly displayName: string;
+    readonly rule: AudienceRule;
+}
+
+/** A rule: every condition given must hold. */
+export declare interface AudienceRule {
+    /** The preferred language starts with one of these (`de` matches `de-AT`). */
+    readonly languages?: ReadonlyArray<string>;
+    /** The request comes from one of these countries. */
+    readonly countries?: ReadonlyArray<string>;
+    /** The reader has (true) or has not (false) been here before. */
+    readonly returning?: boolean;
+}
+
+/** What the server knows about the request, declared — nothing else is consulted. */
+export declare interface AudienceSignals {
+    /** Accept-Language, in order of preference (`de-AT`, `de`, `en`). */
+    readonly languages?: ReadonlyArray<string>;
+    /** ISO 3166-1 alpha-2, from a proxy the app trusts to set it. */
+    readonly country?: string | null;
+    /** The reader allowed being recognised, and was here before. */
+    readonly returning?: boolean;
+}
+
+/** Which fields carry a type's availability. Validated by `defineContentType`. */
+declare interface AvailabilityConfig {
+    /** A date or datetime field: usable up to (excluding) this moment. */
+    readonly until?: string;
+    /** A boolean field: `true` withdraws the document at once. */
+    readonly blocked?: string;
+}
+
+/**
+ * Arrange one variant per document into a tree. `entries` holds at most one
+ * entry per `documentId` (the first one wins). A node without a segment is
+ * not routable and counts as an orphan, and so does everything below it.
+ */
+export declare const buildTree: (entries: ReadonlyArray<TreeEntry>, config: TreeConfig) => CmsTree;
+
+/** The declared fields whose values differ between `before` and `after`, in declaration order. */
+export declare const changedFields: (fields: Readonly<Record<string, unknown>>, before: Readonly<Record<string, unknown>>, after: Readonly<Record<string, unknown>>) => ReadonlyArray<string>;
+
+/** Throws when a declaration cannot work: fields missing or of the wrong kind, a component the field does not allow. */
+export declare const checkTemplates: (name: string, fields: Readonly<Record<string, FieldSchema>>, config: TemplatesConfig) => void;
+
+export declare interface CmsExtensionManifest {
+    /** Lowercase letters, digits and dashes: `reading-time`. */
+    readonly id: string;
+    readonly name: string;
+    /** `major.minor.patch`. */
+    readonly version: string;
+    readonly publisher: string;
+    readonly capabilities: ReadonlyArray<ExtensionCapability>;
+    readonly slots: ReadonlyArray<ExtensionSlot>;
+    /** With the `fieldWidget` slot: the fields it shows beside (field names of the content types). */
+    readonly fields?: ReadonlyArray<string>;
+    /** What an admin can set for it (the `settings` slot): each setting's key, kind, bounds and default. */
+    readonly settings?: ReadonlyArray<ExtensionSetting>;
+}
+
+/** A built tree: every routable node, depth-first, siblings in order. */
+export declare interface CmsTree {
+    readonly nodes: ReadonlyArray<TreeNode>;
+    /**
+     * Documents whose chain never reaches the root — the parent is not
+     * published in any locale the reader accepts, or the parents form a
+     * cycle. They are not routable; they are never hung under the root.
+     */
+    readonly orphans: ReadonlyArray<string>;
+}
 
 /** Everything the write pipeline can fail with on the typed channel. */
-export declare type CmsWriteError = ContentValidationFailed | ContentNotFound | ContentIdConflict;
+export declare type CmsWriteError = ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch;
+
+/** Order of two `major.minor.patch` versions: negative, 0 or positive. */
+export declare const compareVersions: (a: string, b: string) => number;
+
+/**
+ * A component editors compose pages from (ADR-CMS-015): a stable `id`, a
+ * display name and typed props. The frontend renders it; the CMS validates
+ * and stores instances of it. `fingerprint` changes whenever the prop contract
+ * does, so a stored instance can tell which definition it was written against.
+ */
+export declare interface ComponentDefinition {
+    readonly id: string;
+    readonly displayName: string;
+    readonly props: Readonly<Record<string, FieldSchema>>;
+    readonly fingerprint: string;
+    /** The consent purpose a reader must grant before this component's props reach them (`gateConsent`). */
+    readonly consent?: string;
+}
+
+/** One placed component in a `components` field, as stored. */
+export declare interface ComponentInstance {
+    /** Stable across saves, reorders and translations of the same placement. */
+    readonly instanceId: string;
+    readonly componentId: string;
+    /** The definition's fingerprint when this instance was last saved. */
+    readonly fingerprint: string;
+    readonly props: Readonly<Record<string, unknown>>;
+}
+
+/** A reader's choices: purpose id → the version they allowed. */
+export declare type ConsentChoices = Readonly<Record<string, number>>;
+
+/** Something a reader can allow or refuse. */
+export declare interface ConsentPurpose {
+    readonly id: string;
+    /** Raise it when what the reader agrees to changes. */
+    readonly version: number;
+    readonly displayName: string;
+    readonly description: string;
+}
+
+export declare const CONTENT_FORM_STRINGS: ContentFormStrings;
 
 /**
  * Auto-generated content form. Renders one labelled widget per field,
@@ -25,15 +153,142 @@ export declare interface ContentFormProps {
     readonly contentType: ContentFormType;
     readonly value: ContentValue;
     readonly onChange: (next: ContentValue) => void;
+    /**
+     * Override the widget of one field by its name — a select for a string
+     * field only some values make sense in. Wins over `widgets`.
+     */
+    readonly fieldWidgets?: Readonly<Record<string, Widget>>;
     /** Override the widget for one or more editor hints (e.g. a TipTap richText). */
     readonly widgets?: Partial<Record<EditorHint, Widget>>;
+    /**
+     * Renders a control that picks one document of a type — how the rich-text
+     * editor inserts an image asset or a link target. Without it, rich text
+     * offers neither.
+     */
+    readonly renderPicker?: RichDocumentPicker;
+    /**
+     * Renders beside one field, after its control — what the app keeps about
+     * that field (its comments, a hint, who is editing it). `null` renders
+     * nothing. Called once per field on every render.
+     */
+    readonly renderFieldAside?: (name: string) => ReactNode;
+    /**
+     * Renders inside one block of a rich-text field (the built-in editor), after
+     * its actions: `blockId` is the block's stable id, `label` its legend.
+     */
+    readonly renderBlockAside?: (field: string, blockId: string, label: string) => ReactNode;
+    /**
+     * The label a person reads for a field, instead of its name in code: `path`
+     * is the field's name (`title`), or for a component's prop the component id
+     * and the prop (`hero.heading`). `undefined` keeps the name. An app answers
+     * from its message catalog, so the labels follow the editor's language.
+     */
+    readonly fieldLabel?: (path: string) => string | undefined;
+    /** The words of the form's own controls (block and component actions, the
+     *  block editor); English by default. Pass the editor's language. */
+    readonly strings?: ContentFormStringsInput;
+    /** How rich text's paragraphs and headings are edited — see `RichDocumentEditorProps.surface`. */
+    readonly richTextSurface?: 'markup' | 'visual';
+}
+
+export declare interface ContentFormStrings {
+    /** A block's kind, in its legend (`Paragraph 2`) and the "add" picker. */
+    readonly blockNames: Readonly<Record<RichBlock['type'], string>>;
+    readonly moveUp: string;
+    readonly moveDown: string;
+    readonly remove: string;
+    /** The accessible names of the three actions, naming what they act on (`Paragraph 2`). */
+    readonly moveUpLabel: (label: string) => string;
+    readonly moveDownLabel: (label: string) => string;
+    readonly removeLabel: (label: string) => string;
+    readonly add: string;
+    readonly addBlock: string;
+    readonly addComponent: string;
+    readonly unknownComponent: (componentId: string) => string;
+    readonly level: string;
+    readonly numbered: string;
+    /** A nested depth of a list numbered on its own (`depth` 2: the lists one level in). */
+    readonly numberedAt: (depth: number) => string;
+    readonly headerRow: string;
+    readonly image: string;
+    readonly caption: string;
+    readonly text: string;
+    readonly listItems: string;
+    readonly tableRows: string;
+    readonly linkTo: string;
+    readonly linkText: string;
+    readonly insertLink: string;
+    /** A list field's entry, in its legend: the field's label and the position (`Categories 2`). */
+    readonly item: (label: string, position: number) => string;
+    /** The button adding an entry to a list field. */
+    readonly addItem: string;
+    /** The accessible names of the mark buttons of visual text editing. */
+    readonly bold: string;
+    readonly italic: string;
+    readonly underline: string;
 }
 
+/** The defaults with an app's words over them. */
+export declare const contentFormStrings: (strings?: ContentFormStringsInput) => ContentFormStrings;
+
+/** What an app passes: any of the words, and any of the block names. */
+export declare type ContentFormStringsInput = Partial<Omit<ContentFormStrings, 'blockNames'>> & {
+    readonly blockNames?: Partial<ContentFormStrings['blockNames']>;
+};
+
 /** The content-type shape ContentForm reads (structural — avoids a value import). */
 export declare interface ContentFormType {
     readonly fields: Readonly<Record<string, FieldSchema>>;
 }
 
+export declare interface ContentfulImportOptions {
+    /** The document an entry id became, or null. */
+    readonly resolveEntry?: (entryId: string) => string | null;
+    /** The image asset document an asset id became, or null. */
+    readonly resolveAsset?: (assetId: string) => string | null;
+    readonly newId?: () => string;
+}
+
+export declare interface ContentfulImportResult {
+    readonly document: RichDocument;
+    readonly findings: ReadonlyArray<HtmlImportFinding>;
+}
+
+/** A node of Contentful's rich-text document, as the export writes it. */
+export declare interface ContentfulNode {
+    readonly nodeType: string;
+    readonly value?: string;
+    readonly marks?: ReadonlyArray<{
+        readonly type: string;
+    }>;
+    readonly data?: {
+        readonly uri?: string;
+        readonly target?: {
+            readonly sys?: {
+                readonly id?: string;
+                readonly linkType?: string;
+            };
+        };
+    };
+    readonly content?: ReadonlyArray<ContentfulNode>;
+}
+
+/**
+ * A published document had this address and is no longer live — taken down
+ * or archived, with no live page at the address now. A site answers it with
+ * 410 Gone rather than 404, so the address is dropped rather than retried.
+ */
+export declare class ContentGone extends ContentGone_base {
+}
+
+declare const ContentGone_base: Schema_2.TaggedErrorClass<ContentGone, "ContentGone", {
+    readonly _tag: Schema_2.tag<"ContentGone">;
+} & {
+    contentType: typeof Schema_2.String;
+    /** The address asked for. */
+    path: typeof Schema_2.String;
+}>;
+
 /**
  * Raised by `saveDraft` when the caller supplies an explicit `id` that
  * already exists OUTSIDE the caller's scope (another tenant's row).
@@ -64,8 +319,10 @@ declare const ContentNotFound_base: Schema_2.TaggedErrorClass<ContentNotFound, "
 } & {
     contentType: typeof Schema_2.String;
     id: typeof Schema_2.String;
-    /** Which lifecycle table the id was looked up in. */
-    stage: Schema_2.Literal<["draft", "published"]>;
+    /** Which lifecycle table the id was looked up in (`revision`: the
+     *  revision to publish is not one of this variant's; `share`: a preview
+     *  share of the caller's). */
+    stage: Schema_2.Literal<["draft", "published", "revision", "share"]>;
 }>;
 
 /** A registered content type. */
@@ -76,9 +333,31 @@ declare interface ContentType {
     readonly fields: Readonly<Record<string, FieldSchema>>;
     readonly list?: ListConfig;
     readonly idPrefix?: string;
-    /** Declared ISR revalidations fired on publish/unpublish — see
+    /** Declared ISR revalidations fired by `revalidateContent` — see
      *  `ContentTypeSpec.revalidate`. */
     readonly revalidate?: ContentTypeSpec['revalidate'];
+    /** How the documents form a tree — see `ContentTypeSpec.tree`. */
+    readonly tree?: TreeConfig;
+    /** The field a document outside a tree is addressed by — see `ContentTypeSpec.address`. */
+    readonly address?: string;
+    /** Whether publishing needs an approved revision — see `ContentTypeSpec.review`. */
+    readonly review?: {
+        readonly required: boolean | 'workspace';
+    };
+    /** When documents may be used — see `ContentTypeSpec.availability`. */
+    readonly availability?: AvailabilityConfig;
+    /** The review cycle — see `ContentTypeSpec.lifecycle`. */
+    readonly lifecycle?: LifecycleConfig;
+    /** Templates and their rules — see `ContentTypeSpec.templates`. */
+    readonly templates?: TemplatesConfig;
+    /** Whether publishes land in the change feed — see `ContentTypeSpec.changeFeed`. */
+    readonly changeFeed?: boolean;
+    /** What makes a document findable — see `ContentTypeSpec.search`. */
+    readonly search?: SearchConfig;
+    /** What its documents are checked for — see `ContentTypeSpec.quality`. */
+    readonly quality?: ReadonlyArray<QualityRule>;
+    /** The vocabulary of a list field — see `ContentTypeSpec.taxonomy`. */
+    readonly taxonomy?: TaxonomyConfig;
     /** Field names whose value is computed-on-save (derivedFrom). */
     readonly derivedFields: ReadonlyArray<string>;
     /** Field names marked unique-per-tenant (composite `(tenantId, field)` UNIQUE). */
@@ -94,11 +373,86 @@ declare interface ContentTypeSpec {
     readonly list?: ListConfig;
     /** Override the TypeID prefix for awkward plurals / long names. */
     readonly idPrefix?: string;
+    /**
+     * Arrange this type's documents in a tree (pages under pages): `parent` is
+     * an optional `Schema.Reference` to this same type, `order` an optional
+     * number field ordering siblings, `segment` the string field that forms the
+     * path (the slug). Read it with `cms.tree` / `cms.route`.
+     */
+    readonly tree?: TreeConfig;
+    /**
+     * For a type outside a tree whose documents have an address of their own
+     * (a blog post's slug): the string field that is it. Every publish records
+     * it, and a changed address leaves a redirect to the document — as moving a
+     * page in a tree does. Read it with `redirectTarget(store, type, path, scope)`.
+     */
+    readonly address?: string;
+    /**
+     * `required: true` publishes only revisions another editor approved
+     * (`approveReview`) — for every path that publishes: single, release,
+     * rollback, schedule. Register `cmsReviewsTable` when set. `'workspace'`:
+     * each workspace decides (team.ts `setReviewRequired`, or a blueprint's
+     * `team.reviewRequired`) — register `cmsTeamTable` too.
+     */
+    readonly review?: {
+        readonly required: boolean | 'workspace';
+    };
+    /**
+     * When this type's documents may be used (`until`: a date/datetime field,
+     * `blocked`: a boolean field). Publishing one records it; publishing
+     * anything referencing a blocked or expired one is refused
+     * (`ReferenceUnavailable`), and readers can leave it out
+     * (`unavailableAmong`). Register `cmsAvailabilityTable` when set.
+     */
+    readonly availability?: AvailabilityConfig;
+    /**
+     * How often a published document is checked again: its first publish sets
+     * a review date `reviewEveryDays` ahead, `recertify` moves it on. Register
+     * `cmsStewardshipTable` (it also holds each document's owner).
+     */
+    readonly lifecycle?: LifecycleConfig;
+    /**
+     * Templates a new document can start from, and the rules a document built
+     * from one keeps on every save (required components, the first one, at
+     * most N of one). `field` stores the template id.
+     */
+    readonly templates?: TemplatesConfig;
+    /**
+     * Append every publish and take-down of this type to the change feed
+     * (`cms_changes`, read with `readChanges`), in the same transaction. Register
+     * `cmsChangesTable` when set.
+     */
+    readonly changeFeed?: boolean;
+    /**
+     * Make this type findable (`searchContent`): every save and publish writes
+     * the variant's text to `cms_search` in the same transaction — `title`
+     * ranked first, all other text (strings, rich text, component props) as the
+     * body. Register `cmsSearchTable` when set.
+     */
+    readonly search?: SearchConfig;
+    /**
+     * Quality rules (quality.ts): each names the causing field, the words an
+     * editor reads, and whether publishing waits for it (`blocking`, default
+     * true). A blocking finding is repaired at its field or excepted — one rule,
+     * one variant, a reason, an end date, approved by someone else
+     * (`requestQualityException` / `decideQualityException`). Register
+     * `cmsQualityExceptionsTable` when set.
+     */
+    readonly quality?: ReadonlyArray<QualityRule>;
+    /**
+     * A controlled vocabulary for one `Schema.Array(Schema.String)` field
+     * (taxonomy.ts): every save folds case and spacing, maps synonyms to their
+     * term and drops repeats; a term outside the vocabulary fails the save
+     * (`unknown: 'keep'` keeps it).
+     */
+    readonly taxonomy?: TaxonomyConfig;
     /**
      * ISR routes to drop when content of this type is published or
-     * unpublished — `publish()`/`unpublish()` call `revalidatePath` /
-     * `revalidateTag` (from `@voltro/runtime`) for each entry after the
-     * write commits, reaching every `voltro start` replica.
+     * unpublished. `revalidateContent(type)` calls `revalidatePath` /
+     * `revalidateTag` (from `@voltro/runtime`) for each entry, reaching every
+     * `voltro start` replica — `publishDue` after its commits, a mutation from
+     * a post-commit subscriber on `<type>_published` (the write ops run inside
+     * the caller's transaction, so they cannot know when it commits).
      *
      * You DON'T need this on postgres for the plain publish case: a route
      * declaring `cacheInvalidatesOn: ['<type>_published']` is already dropped
@@ -139,9 +493,9 @@ export declare type ContentValue = Record<string, unknown>;
 /**
  * Collect every save-time rule violation for `row` against `type` —
  * required presence, per-kind type checks, `maxLength`, `pattern`,
- * `Literal` value sets, and the rich-text content policy
- * (`allowImages` / `allowEmbeds: false` reject image/embed nodes or the
- * `<img>` / `<iframe>` / `<embed>` markers in string values).
+ * `Literal` value sets, component instances, and rich documents (their
+ * structure, and image / link nodes only where the field names a type for
+ * them).
  *
  * Pure and never throws — usable in a browser form ("annotate every
  * invalid field") as well as on the server. `id` is allowed (must be a
@@ -154,7 +508,22 @@ export declare type ContentValue = Record<string, unknown>;
  * that is about to be written — a derived field's rules apply to the
  * derived value, not to a caller value that's about to be overwritten.
  */
-export declare const contentViolations: (type: Pick<ContentType, "name" | "fields">, row: Readonly<Record<string, unknown>>) => ReadonlyArray<FieldViolation>;
+export declare const contentViolations: (type: Pick<ContentType, "name" | "fields"> & Partial<Pick<ContentType, "taxonomy">>, row: Readonly<Record<string, unknown>>) => ReadonlyArray<FieldViolation>;
+
+/** Decode character references (`&amp;`, `&#8217;`, `&#x2014;`). */
+export declare const decodeEntities: (text: string) => string;
+
+/** Define an audience; a rule with no condition would match everyone and is refused. */
+export declare const defineAudience: (audience: Audience) => Audience;
+
+/** Declare a component editors can place in a `Schema.Components` field. */
+export declare const defineComponent: (spec: {
+    readonly id: string;
+    readonly displayName: string;
+    readonly props: Readonly<Record<string, FieldSchema | PipeableField>>;
+    /** A consent purpose the reader must grant first — an embed that loads a third party. */
+    readonly consent?: string;
+}) => ComponentDefinition;
 
 /**
  * Mark a field computed-on-save from another field. The transform runs
@@ -175,11 +544,195 @@ export declare interface DerivedSpec {
     readonly transform: (value: unknown, row: Record<string, unknown>) => unknown;
 }
 
+/**
+ * Name the change from `before` to `after`, or null when nothing declared
+ * changed. A component or block list names the item added, removed, moved or
+ * edited; any other field is "edit <field>".
+ */
+export declare const describeEdit: (fields: Readonly<Record<string, FieldSchema>>, before: Readonly<Record<string, unknown>>, after: Readonly<Record<string, unknown>>, words: EditWords) => EditDescription | null;
+
+/** One run of a word diff: text both sides share, or text only one side has. */
+export declare interface DiffSegment {
+    readonly op: 'same' | 'removed' | 'added';
+    readonly text: string;
+}
+
+/**
+ * The word diff of two texts: the longest common run of words kept as `same`,
+ * the rest as `removed` (only before) and `added` (only after), adjacent runs
+ * of one kind merged. Two very long texts come back as one removed and one
+ * added run.
+ */
+export declare const diffWords: (before: string, after: string) => ReadonlyArray<DiffSegment>;
+
+/** What one change did, and a key that tells whether the next change continues it. */
+export declare interface EditDescription {
+    readonly label: string;
+    /** Changes with the same key in quick succession are one step (typing). */
+    readonly key: string;
+}
+
+export declare interface EditHistory {
+    /** Oldest first; the last one is undone next. */
+    readonly past: ReadonlyArray<EditStep>;
+    /** Next first: what redo does. */
+    readonly future: ReadonlyArray<EditStep>;
+}
+
 /** The widget the editor renders for a field — drives ContentForm. */
-export declare type EditorHint = 'text' | 'textarea' | 'number' | 'boolean' | 'date' | 'datetime' | 'select' | 'richText' | 'media' | 'reference' | 'array' | 'struct';
+export declare type EditorHint = 'text' | 'textarea' | 'number' | 'boolean' | 'date' | 'datetime' | 'select' | 'richText' | 'media' | 'reference' | 'array' | 'struct' | 'components';
+
+/** What the editor sends the preview. */
+export declare interface EditorMessage {
+    readonly protocol: typeof VISUAL_EDITING_PROTOCOL;
+    readonly nonce: string;
+    readonly kind: 'values';
+    readonly values: Readonly<Record<string, unknown>>;
+}
+
+/** One step: the form as it was before it, and its name. */
+export declare interface EditStep {
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly label: string;
+    readonly key: string;
+    readonly at: number;
+}
+
+/** The words a step is named with, in the editor's language. */
+export declare interface EditWords {
+    readonly fieldLabel: (name: string) => string;
+    readonly componentLabel: (componentId: string) => string;
+    readonly blockLabel: (type: RichBlock['type']) => string;
+    readonly edit: (what: string) => string;
+    readonly add: (what: string) => string;
+    readonly remove: (what: string) => string;
+    readonly moveUp: (what: string) => string;
+    readonly moveDown: (what: string) => string;
+    /** Two neighbours that changed places — which of them was moved cannot be told from the result. */
+    readonly swap: (first: string, second: string) => string;
+}
+
+/** The tools on for the last step of `chain`, and why each tool is as it is. */
+export declare const effectiveExposure: (input: ExposureInput) => ExposureResult;
+
+export declare const EMPTY_EDIT_HISTORY: EditHistory;
+
+/** An empty document. */
+export declare const emptyRichDocument: () => RichDocument;
+
+export declare interface ExposureInput {
+    readonly ceiling: ReadonlyArray<string>;
+    readonly defaults: ReadonlyArray<string>;
+    /** From the root down to the page. */
+    readonly chain: ReadonlyArray<ExposureStep>;
+}
+
+export declare interface ExposureResult {
+    /** The tools on here, in the ceiling's order. */
+    readonly tools: ReadonlyArray<string>;
+    /** Every tool of the ceiling and why it is as it is. */
+    readonly explained: ReadonlyArray<ToolExposure>;
+}
+
+/** One level of the tree: tool names turned on, off, or locked off here. A value that is not a list of names counts as unset. */
+export declare interface ExposureStep {
+    readonly on?: unknown;
+    readonly off?: unknown;
+    readonly locked?: unknown;
+}
+
+/** The places in the editor an extension can show itself. */
+export declare const EXTENSION_SLOTS: readonly ["dashboard", "sidebar", "fieldWidget", "entryTab", "releaseCheck", "assetAction", "settings"];
+
+/** An extension reached for a capability it was not granted. */
+export declare class ExtensionAccessDenied extends ExtensionAccessDenied_base {
+}
+
+declare const ExtensionAccessDenied_base: Schema_2.TaggedErrorClass<ExtensionAccessDenied, "ExtensionAccessDenied", {
+    readonly _tag: Schema_2.tag<"ExtensionAccessDenied">;
+} & {
+    extensionId: typeof Schema_2.String;
+    capability: typeof Schema_2.String;
+}>;
+
+/**
+ * What an extension may do; everything else is refused.
+ *
+ *   content:read / content:write — documents, through the CMS, never its tables;
+ *   egress:<host>                — HTTPS requests to exactly that host;
+ *   secret:<NAME>                — that one secret, as the host binds it.
+ *
+ * Its own data (`data` in the sandbox) needs no capability: it lives in the
+ * extension's namespace and leaves with it.
+ */
+export declare type ExtensionCapability = 'content:read' | 'content:write' | `egress:${string}` | `secret:${string}`;
+
+/** A manifest on the wire — for a descriptor's input or output. */
+export declare const ExtensionManifestSchema: Schema_2.Struct<{
+    id: typeof Schema_2.String;
+    name: typeof Schema_2.String;
+    version: typeof Schema_2.String;
+    publisher: typeof Schema_2.String;
+    capabilities: Schema_2.Array$<typeof Schema_2.String>;
+    slots: Schema_2.Array$<typeof Schema_2.String>;
+    fields: Schema_2.optional<Schema_2.Array$<typeof Schema_2.String>>;
+    settings: Schema_2.optional<Schema_2.Array$<Schema_2.Union<[Schema_2.Struct<{
+        key: typeof Schema_2.String;
+        label: typeof Schema_2.String;
+        kind: Schema_2.Literal<["number"]>;
+        default: typeof Schema_2.Number;
+        min: Schema_2.optional<typeof Schema_2.Number>;
+        max: Schema_2.optional<typeof Schema_2.Number>;
+    }>, Schema_2.Struct<{
+        key: typeof Schema_2.String;
+        label: typeof Schema_2.String;
+        kind: Schema_2.Literal<["boolean"]>;
+        default: typeof Schema_2.Boolean;
+    }>, Schema_2.Struct<{
+        key: typeof Schema_2.String;
+        label: typeof Schema_2.String;
+        kind: Schema_2.Literal<["choice"]>;
+        default: typeof Schema_2.String;
+        options: Schema_2.Array$<typeof Schema_2.String>;
+    }>]>>>;
+}>;
+
+/** One setting of an extension. A number may have bounds; a choice lists its options. */
+export declare type ExtensionSetting = {
+    readonly key: string;
+    readonly label: string;
+    readonly kind: 'number';
+    readonly default: number;
+    readonly min?: number;
+    readonly max?: number;
+} | {
+    readonly key: string;
+    readonly label: string;
+    readonly kind: 'boolean';
+    readonly default: boolean;
+} | {
+    readonly key: string;
+    readonly label: string;
+    readonly kind: 'choice';
+    readonly default: string;
+    readonly options: ReadonlyArray<string>;
+};
+
+export declare type ExtensionSettingValue = number | boolean | string;
+
+export declare type ExtensionSlot = (typeof EXTENSION_SLOTS)[number];
+
+/** One changed field, as a word diff of its text before and after. */
+export declare interface FieldDiff {
+    readonly field: string;
+    readonly segments: ReadonlyArray<DiffSegment>;
+}
+
+/** How each declared field that changed between `before` and `after` changed, in declaration order. */
+export declare const fieldDiffs: (fields: Readonly<Record<string, unknown>>, before: Readonly<Record<string, unknown>>, after: Readonly<Record<string, unknown>>) => ReadonlyArray<FieldDiff>;
 
 /** Discriminator for how a field compiles to a column + serialises. */
-export declare type FieldKind = 'string' | 'number' | 'boolean' | 'date' | 'datetime' | 'literal' | 'richText' | 'media' | 'reference' | 'array' | 'struct';
+export declare type FieldKind = 'string' | 'number' | 'boolean' | 'date' | 'datetime' | 'literal' | 'richText' | 'media' | 'reference' | 'array' | 'struct' | 'components';
 
 /** A refinement applied through `.pipe(...)`. */
 export declare type FieldRefinement = (field: FieldSchema) => FieldSchema;
@@ -190,12 +743,20 @@ export declare interface FieldSchema {
     readonly editorHint: EditorHint;
     /** When true the field is nullable in the DB + optional in the editor. */
     readonly isOptional: boolean;
+    /**
+     * Set by `.requiredToPublish()`: a draft may leave it empty; publishing
+     * needs it (`publishViolations`, checked by every publish). Implies
+     * `isOptional` — the column is nullable.
+     */
+    readonly publishRequired?: boolean;
     /** Max string length — drives textarea-vs-input + save-time validation. */
     readonly maxLength?: number;
     /** Source-form regex (string) for save-time validation. */
     readonly pattern?: string;
     /** Closed value set for `literal` fields → `<select>` + CHECK constraint. */
     readonly literals?: ReadonlyArray<string>;
+    /** A `number` field that takes fractions (a `real` column); without it a number is whole. */
+    readonly fraction?: boolean;
     /**
      * When true, the field is unique PER TENANT — the derived tables carry a
      * composite `(tenantId, <field>)` DB UNIQUE constraint (see contentType.ts).
@@ -210,10 +771,29 @@ export declare interface FieldSchema {
     readonly element?: FieldSchema;
     /** Nested field map for `struct` fields. */
     readonly struct?: Readonly<Record<string, FieldSchema>>;
+    /** The components a `components` field may hold, in the order editors see them. */
+    readonly components?: ReadonlyArray<ComponentDefinition>;
     /** Computed-on-save derivation (set via `derivedFrom`). */
     readonly derived?: DerivedSpec;
 }
 
+/** One value a field held, from the revision that introduced it. */
+export declare interface FieldVersion {
+    readonly value: unknown;
+    readonly revisionId: string;
+    readonly number: number;
+    readonly createdAt: unknown;
+    readonly createdBy: unknown;
+}
+
+/**
+ * The versions of one field across a document's revisions, newest first: a
+ * new entry wherever the value changed. For an image asset's `file` it is the
+ * file history — a revision that only fixed the alt text adds no version.
+ * `revisions` are `cms_revisions` rows (e.g. from `listRevisions`), in any order.
+ */
+export declare const fieldVersions: (revisions: ReadonlyArray<Readonly<Record<string, unknown>>>, field: string) => ReadonlyArray<FieldVersion>;
+
 /** One save-time rule violation, addressed to a field path. */
 export declare interface FieldViolation {
     /** Dotted/indexed field path, e.g. `title`, `meta.ogTitle`, `tags[2]`. */
@@ -223,6 +803,111 @@ export declare interface FieldViolation {
     readonly message: string;
 }
 
+/**
+ * The part of a `ContentForm` a path names — a field's container, or one
+ * placed component of a components field — or null.
+ */
+export declare const formPartOf: (form: ParentNode, path: string) => Element | null;
+
+/**
+ * The values with every component that needs an ungranted purpose replaced
+ * by a {@link WithheldInstance}. Values without such components come back
+ * unchanged. Apply it wherever content leaves for a reader.
+ */
+export declare const gateConsent: (type: {
+    readonly fields: Readonly<Record<string, FieldSchema>>;
+}, values: Readonly<Record<string, unknown>>, granted: ReadonlySet<string>) => Record<string, unknown>;
+
+/** The purposes whose current version the reader allowed. */
+export declare const grantedPurposes: (purposes: ReadonlyArray<ConsentPurpose>, choices: ConsentChoices) => ReadonlySet<string>;
+
+/** Whether every character of text in `[start, end)` carries `mark` (links never do). */
+export declare const hasMark: (content: ReadonlyArray<RichInline>, start: number, end: number, mark: RichMark) => boolean;
+
+export declare interface HtmlImportFinding {
+    readonly kind: 'unsupportedTag' | 'externalLink' | 'image';
+    /** The tag, the link's address or the image's source. */
+    readonly detail: string;
+}
+
+export declare interface HtmlImportOptions {
+    /** The document an address points to, or null when it is not one of ours. */
+    readonly resolveLink?: (href: string) => string | null;
+    /** The image asset document an image source became (an import that brought the file in), or null. */
+    readonly resolveImage?: (src: string) => string | null;
+    /** Block ids; defaults to a counter, so a test reads stable ids. */
+    readonly newId?: () => string;
+}
+
+export declare interface HtmlImportResult {
+    readonly document: RichDocument;
+    readonly findings: ReadonlyArray<HtmlImportFinding>;
+}
+
+/** Where an inherited value came from. */
+export declare interface Inherited {
+    /** The value; undefined when neither the page nor an ancestor sets it. */
+    readonly value: unknown;
+    /** The document that set it: the page itself, an ancestor, or null for none. */
+    readonly from: string | null;
+}
+
+/**
+ * The value of an inherited field for `node`: its own when set, else the
+ * nearest ancestor's in `tree` (the same locale's variants the tree was built
+ * from). Pass `{ ancestorsOnly: true }` for what the page would show without
+ * its own value — the "reset to inherited" preview.
+ */
+export declare const inheritedValue: (tree: CmsTree, node: TreeNode, field: string, options?: {
+    readonly ancestorsOnly?: boolean;
+}) => Inherited;
+
+/** How one inherited field may be set. */
+export declare interface InheritRule {
+    /** No page may set the field; saving one that does is refused (`locked`). */
+    readonly locked?: boolean;
+}
+
+/** The minimal DOM a surface is read from (a browser element, or jsdom's). */
+export declare interface InlineDomNode {
+    readonly nodeType: number;
+    readonly nodeName: string;
+    readonly textContent: string | null;
+    readonly childNodes: ArrayLike<InlineDomNode>;
+    getAttribute?(name: string): string | null;
+}
+
+/**
+ * Read a surface's DOM back into a run: text, `strong`/`b` as bold, `em`/`i` as
+ * italic, `a[data-target]` as a link to that document, `br` as a line break.
+ * Anything else a browser or a paste put there contributes its text only.
+ */
+export declare const inlineFromDom: (root: InlineDomNode) => ReadonlyArray<RichInline>;
+
+/** A run as the HTML a visual surface shows: `strong`, `em`, `u`, `a[data-target]`, escaped text. */
+export declare const inlineHtml: (content: ReadonlyArray<RichInline>) => string;
+
+/** Inline nodes back to the editor's markup (the inverse of `parseInlineMarkup`). */
+export declare const inlineMarkupOf: (content: ReadonlyArray<RichInline>) => string;
+
+/** The plain text of a run. */
+export declare const inlineText: (content: ReadonlyArray<RichInline>) => string;
+
+/** Whether `value` is a capability an extension can ask for. */
+export declare const isExtensionCapability: (value: string) => value is ExtensionCapability;
+
+/** Whether `zone` is an IANA zone this runtime knows. */
+export declare const isKnownZone: (zone: string) => boolean;
+
+/** Accept-Language → languages in order of preference (quality factors honoured). */
+export declare const languagesOf: (acceptLanguage: string | undefined) => ReadonlyArray<string>;
+
+/** How often a type's documents are checked again, declared on the type. */
+declare interface LifecycleConfig {
+    /** Days from a publish or a recertification to the next review. */
+    readonly reviewEveryDays: number;
+}
+
 /**
  * List-view configuration for the consuming editor/template: which
  * columns its list page shows and the default sort. Validated by
@@ -238,28 +923,510 @@ declare interface ListConfig {
     };
 }
 
+/** Whether a (nested) list is numbered. */
+export declare type ListKind = 'ordered' | 'unordered';
+
+/** Whether the list's items at `depth` (0: the top) are numbered. */
+export declare const listNumberedAt: (block: {
+    readonly ordered: boolean;
+    readonly sublists?: ReadonlyArray<ListKind>;
+}, depth: number) => boolean;
+
+/** One language's published page tree. */
+export declare interface LocalizedTree {
+    readonly locale: string;
+    readonly tree: CmsTree;
+}
+
+/** What is wrong with a manifest; empty when nothing is. */
+export declare const manifestProblems: (manifest: CmsExtensionManifest) => ReadonlyArray<string>;
+
+/** Whether the request's signals meet the rule. */
+export declare const matchesAudience: (rule: AudienceRule, signals: AudienceSignals) => boolean;
+
+/** How a returned file's units line up with the source's: translated, left as source, unknown, and missing. */
+export declare const matchUnits: (source: ReadonlyArray<TranslationUnit>, returned: ReadonlyArray<TranslationUnit>) => {
+    readonly translated: number;
+    readonly untranslated: number;
+    readonly unknown: ReadonlyArray<string>;
+    readonly missing: ReadonlyArray<string>;
+};
+
+/** The deepest a list item may sit (0 is the top). */
+export declare const MAX_LIST_LEVEL = 3;
+
+export declare const MAX_OCCURRENCES = 100;
+
 /** Cap a string field's length. Past `value` the editor renders a textarea. */
 export declare const maxLength: (value: number) => FieldRefinement;
 
+/** Adjacent text runs with the same marks become one; empty text runs go. */
+export declare const mergeInline: (content: ReadonlyArray<RichInline>) => ReadonlyArray<RichInline>;
+
+/** `list` with the entry at `from` moved to `to` (clamped); the same list when nothing moves. */
+export declare const moveEntry: <T>(list: ReadonlyArray<T>, from: number, to: number) => ReadonlyArray<T>;
+
+/** A fresh block id. */
+export declare const newBlockId: () => string;
+
+/** The capabilities `requested` asks for beyond `granted` — what needs a new consent. */
+export declare const newCapabilities: (granted: ReadonlyArray<ExtensionCapability>, requested: ReadonlyArray<ExtensionCapability>) => ReadonlyArray<ExtensionCapability>;
+
+/** A nonce for one editing session (unguessable; 128 bits). */
+export declare const newVisualNonce: () => string;
+
+/**
+ * The canonical form of a stored value: a plain string becomes paragraphs (a
+ * blank line starts a new one), a document keeps its blocks and gets an id on
+ * every block that lacks one, anything else is returned as is for the
+ * validator to reject.
+ */
+export declare const normalizeRichDocument: (value: unknown) => unknown;
+
+/** The vocabulary's terms for `input`, in first-seen order, and what it does not know. */
+export declare const normalizeTerms: (config: Pick<TaxonomyConfig, "terms">, input: ReadonlyArray<unknown>) => {
+    readonly terms: ReadonlyArray<string>;
+    readonly unknown: ReadonlyArray<string>;
+};
+
+export declare interface Occurrence {
+    /** Its position in the series, from 0 (counting excepted ones). */
+    readonly index: number;
+    /** The local wall time it was meant for. */
+    readonly local: string;
+    readonly startsAt: Date;
+    readonly endsAt: Date;
+    /** `gap`: the wall time did not exist, moved after it; `fold`: it existed twice, the first; `clamped`: the month had no such day. */
+    readonly adjusted?: 'gap' | 'fold' | 'clamped';
+}
+
+/** The occurrences of a rule, in order; throws `RangeError` for a rule with problems. */
+export declare const occurrencesOf: (rule: RecurrenceRule) => ReadonlyArray<Occurrence>;
+
+/** Where a document lives in one language. */
+export declare interface PageAlternate {
+    readonly locale: string;
+    readonly path: string;
+}
+
+/** One template a content type offers. */
+export declare interface PageTemplate {
+    /** Stable id, stored on the document. */
+    readonly id: string;
+    readonly displayName: string;
+    /** Field values a new document starts with (e.g. a layout). */
+    readonly values?: Readonly<Record<string, unknown>>;
+    /** The components a new document starts with, in order. */
+    readonly sections?: ReadonlyArray<{
+        readonly component: ComponentDefinition;
+        readonly props?: Readonly<Record<string, unknown>>;
+    }>;
+    /** Components the document must always hold at least once. */
+    readonly required?: ReadonlyArray<ComponentDefinition>;
+    /** The component that must come first. */
+    readonly first?: ComponentDefinition;
+    /** The most of one component the document may hold. */
+    readonly max?: ReadonlyArray<{
+        readonly component: ComponentDefinition;
+        readonly count: number;
+    }>;
+}
+
+/** Parse the editor's inline markup into inline nodes. Unclosed markers stay text. */
+export declare const parseInlineMarkup: (input: string) => ReadonlyArray<RichInline>;
+
+/** `sections.2` → `{ field: 'sections', index: 2 }`; `title` → `{ field: 'title' }`. */
+export declare const parseSourcePath: (path: string) => {
+    readonly field: string;
+    readonly index?: number;
+};
+
+/** Read an XLIFF 2.x file with one `<file>`: languages, notes and each unit's source and target. */
+export declare const parseXliff: (xml: string) => XliffExchange;
+
 /** Constrain a string field to a regex (source form, validated on save). */
 export declare const pattern: (re: RegExp) => FieldRefinement;
 
+/** The first variant whose audience matches, or null for the original. Variants naming an unknown audience never match. */
+export declare const pickVariant: <V extends {
+    readonly audience: string;
+}>(variants: ReadonlyArray<V>, audiences: ReadonlyArray<Audience>, signals: AudienceSignals) => V | null;
+
 export declare interface PipeableField extends FieldSchema {
     readonly isOptional: boolean;
     pipe(...refinements: ReadonlyArray<FieldRefinement>): PipeableField;
     /** Mark the field optional → nullable column + non-required editor input. */
     optional(): PipeableField;
+    /**
+     * Let a draft be saved without it, and refuse to publish until it is set —
+     * an image uploaded in bulk before anyone wrote its alt text. The column is
+     * nullable, like `optional()`.
+     */
+    requiredToPublish(): PipeableField;
 }
 
+/** The document's text, one line per block — for excerpts and search. */
+export declare const plainTextOf: (doc: RichDocument) => string;
+
+/** What the preview sends the editor. `path` is a field (`title`) or a component (`sections.2`). */
+export declare type PreviewMessage = {
+    readonly protocol: typeof VISUAL_EDITING_PROTOCOL;
+    readonly nonce: string;
+    readonly kind: 'ready';
+} | {
+    readonly protocol: typeof VISUAL_EDITING_PROTOCOL;
+    readonly nonce: string;
+    readonly kind: 'select';
+    readonly path: string;
+} | {
+    readonly protocol: typeof VISUAL_EDITING_PROTOCOL;
+    readonly nonce: string;
+    readonly kind: 'move';
+    readonly path: string;
+    readonly to: number;
+};
+
 /**
- * Options carried by a RichText field, enforced at save time by
- * `validateContent`: an explicit `false` REJECTS the content class
- * (image/embed nodes in a structured document, or `<img>` / `<iframe>` /
- * `<embed>` markers in a string value); `true` or omitted allows it.
+ * Raised by `createPreviewShare` when the requested expiry is not in the
+ * future or lies beyond the longest a preview link may live.
+ */
+export declare class PreviewShareRejected extends PreviewShareRejected_base {
+}
+
+declare const PreviewShareRejected_base: Schema_2.TaggedErrorClass<PreviewShareRejected, "PreviewShareRejected", {
+    readonly _tag: Schema_2.tag<"PreviewShareRejected">;
+} & {
+    reason: Schema_2.Literal<["expiryInPast", "expiryTooFar"]>;
+}>;
+
+/**
+ * What stops these values from being published: every `requiredToPublish()`
+ * field that is empty (absent, null, or a blank string). Browser-safe, so an
+ * editor can say so before the publish is refused.
+ */
+export declare const publishViolations: (type: Pick<ContentType, "fields">, values: Readonly<Record<string, unknown>>) => ReadonlyArray<FieldViolation>;
+
+/** The purposes the components of `type` need, for a banner to ask about. */
+export declare const purposesUsedBy: (type: {
+    readonly fields: Readonly<Record<string, FieldSchema>>;
+}) => ReadonlySet<string>;
+
+/** One quality check of a type — see `ContentTypeSpec.quality`. */
+declare interface QualityRule {
+    /** Stable id (letters, digits, `.`, `-`), unique in the type — exceptions name it. */
+    readonly id: string;
+    /** The field that causes the finding and where it is repaired. */
+    readonly field: string;
+    /** What is wrong, in the editor's words. */
+    readonly message: string;
+    /** Whether publishing waits for a repair or an approved exception. Default true. */
+    readonly blocking?: boolean;
+    /** True when the values have the finding. Pure. */
+    readonly check: (values: Readonly<Record<string, unknown>>) => boolean;
+}
+
+/**
+ * Raised when a create would take a tenant past a limit its app set — more
+ * documents, keys or environments than it may hold. Nothing was written;
+ * `used` is what the tenant holds now.
+ */
+export declare class QuotaExceeded extends QuotaExceeded_base {
+}
+
+declare const QuotaExceeded_base: Schema_2.TaggedErrorClass<QuotaExceeded, "QuotaExceeded", {
+    readonly _tag: Schema_2.tag<"QuotaExceeded">;
+} & {
+    quota: typeof Schema_2.String;
+    limit: typeof Schema_2.Number;
+    used: typeof Schema_2.Number;
+}>;
+
+/** The editor's message, or null for anything else. */
+export declare const readEditorMessage: (event: VisualMessageEvent, session: VisualSession) => EditorMessage | null;
+
+/** The preview's message, or null for anything else (another origin, another session, another shape). */
+export declare const readPreviewMessage: (event: VisualMessageEvent, session: VisualSession) => PreviewMessage | null;
+
+/**
+ * Record a change: `before` is the form as it was. A change with the same key
+ * within `mergeMs` of the last step continues it (typing is one step). The
+ * redo branch goes; at most `limit` steps are kept.
+ */
+export declare const recordEdit: (history: EditHistory, before: Readonly<Record<string, unknown>>, edit: EditDescription, at: number, options?: {
+    readonly mergeMs?: number;
+    readonly limit?: number;
+}) => EditHistory;
+
+export declare type RecurrenceEvery = 'day' | 'week' | 'month';
+
+/** What is wrong with a rule, in words; empty when it can be scheduled. */
+export declare const recurrenceProblems: (rule: RecurrenceRule) => ReadonlyArray<string>;
+
+export declare interface RecurrenceRule {
+    /** The first occurrence, as a local wall time: `YYYY-MM-DDTHH:mm`. */
+    readonly start: string;
+    /** The IANA zone the wall time is in (`Europe/Berlin`). */
+    readonly zone: string;
+    readonly every: RecurrenceEvery;
+    /** Every how many days / weeks / months (default 1). */
+    readonly interval?: number;
+    /** How many positions the series has (1–100); an excepted one is left out. */
+    readonly count: number;
+    /** How long each occurrence is live, in minutes; shorter than one step. */
+    readonly durationMinutes: number;
+    /** Local dates (`YYYY-MM-DD`) that are left out. */
+    readonly except?: ReadonlyArray<string>;
+}
+
+/** Redo the step undone last; null when there is nothing to redo. */
+export declare const redoEdit: (history: EditHistory, current: Readonly<Record<string, unknown>>) => {
+    readonly history: EditHistory;
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly label: string;
+} | null;
+
+/**
+ * Raised when a revision references documents that may not be used — blocked
+ * or past their availability — naming each and where it is referenced.
+ */
+export declare class ReferenceUnavailable extends ReferenceUnavailable_base {
+}
+
+declare const ReferenceUnavailable_base: Schema_2.TaggedErrorClass<ReferenceUnavailable, "ReferenceUnavailable", {
+    readonly _tag: Schema_2.tag<"ReferenceUnavailable">;
+} & {
+    contentType: typeof Schema_2.String;
+    id: typeof Schema_2.String;
+    targets: Schema_2.Array$<Schema_2.Struct<{
+        path: typeof Schema_2.String;
+        contentType: typeof Schema_2.String;
+        documentId: typeof Schema_2.String;
+        reason: Schema_2.Literal<["blocked", "expired"]>;
+    }>>;
+}>;
+
+/**
+ * Raised when a release is asked to change in a state that does not allow it:
+ * adding to or scheduling a release that is no longer a draft, publishing one
+ * that is already published or failed, rolling back one that is not published.
+ */
+export declare class ReleaseNotEditable extends ReleaseNotEditable_base {
+}
+
+declare const ReleaseNotEditable_base: Schema_2.TaggedErrorClass<ReleaseNotEditable, "ReleaseNotEditable", {
+    readonly _tag: Schema_2.tag<"ReleaseNotEditable">;
+} & {
+    id: typeof Schema_2.String;
+    status: typeof Schema_2.String;
+}>;
+
+/**
+ * Replace the text in `[start, end)` with `text` (a paste, a typed line
+ * break). It takes the marks of the first character it replaces, or — where
+ * nothing is selected — of the character before it.
+ */
+export declare const replaceText: (content: ReadonlyArray<RichInline>, start: number, end: number, text: string) => ReadonlyArray<RichInline>;
+
+/**
+ * Raised when a revision of a content type that requires review is published
+ * without an approval of exactly that revision.
+ */
+export declare class ReviewRequired extends ReviewRequired_base {
+}
+
+declare const ReviewRequired_base: Schema_2.TaggedErrorClass<ReviewRequired, "ReviewRequired", {
+    readonly _tag: Schema_2.tag<"ReviewRequired">;
+} & {
+    contentType: typeof Schema_2.String;
+    id: typeof Schema_2.String;
+    revisionId: typeof Schema_2.String;
+}>;
+
+/**
+ * Raised by the review steps when the step does not fit the variant's review:
+ * nothing is in review, or the approver is the person who asked for it.
+ */
+export declare class ReviewStepRefused extends ReviewStepRefused_base {
+}
+
+declare const ReviewStepRefused_base: Schema_2.TaggedErrorClass<ReviewStepRefused, "ReviewStepRefused", {
+    readonly _tag: Schema_2.tag<"ReviewStepRefused">;
+} & {
+    contentType: typeof Schema_2.String;
+    id: typeof Schema_2.String;
+    reason: Schema_2.Literal<["notInReview", "selfApproval"]>;
+}>;
+
+/**
+ * Raised by `publish` when the caller pinned a revision (`{ revisionId }`)
+ * and the draft has moved on to another one — publishing would release
+ * content that was not the reviewed revision.
+ */
+export declare class RevisionMismatch extends RevisionMismatch_base {
+}
+
+declare const RevisionMismatch_base: Schema_2.TaggedErrorClass<RevisionMismatch, "RevisionMismatch", {
+    readonly _tag: Schema_2.tag<"RevisionMismatch">;
+} & {
+    contentType: typeof Schema_2.String;
+    id: typeof Schema_2.String;
+    expected: typeof Schema_2.String;
+    actual: typeof Schema_2.String;
+}>;
+
+/** A top-level block. `id` is stable across edits, moves and translations. */
+export declare type RichBlock = {
+    readonly id: string;
+    readonly type: 'paragraph';
+    readonly content: ReadonlyArray<RichInline>;
+} | {
+    readonly id: string;
+    readonly type: 'heading';
+    readonly level: 2 | 3;
+    readonly content: ReadonlyArray<RichInline>;
+} | {
+    readonly id: string;
+    readonly type: 'list';
+    readonly ordered: boolean;
+    readonly items: ReadonlyArray<ReadonlyArray<RichInline>>;
+    /** How deep each item sits (0 at the top, at most `MAX_LIST_LEVEL`), one per item; absent: all at the top.
+     *  An item is at most one level deeper than the one before it. */
+    readonly levels?: ReadonlyArray<number>;
+    /** The kind of the lists nested in it, by depth — index 0 for the lists one level in. Absent (or
+     *  shorter than the depth): numbered like the list itself. At most `MAX_LIST_LEVEL` entries. */
+    readonly sublists?: ReadonlyArray<ListKind>;
+} | {
+    readonly id: string;
+    readonly type: 'table';
+    /** True when the first row holds the column headers. */
+    readonly header: boolean;
+    readonly rows: ReadonlyArray<ReadonlyArray<ReadonlyArray<RichInline>>>;
+}
+/** An image asset (by its documentId) with an optional caption. */
+| {
+    readonly id: string;
+    readonly type: 'image';
+    readonly asset: string;
+    readonly caption?: string;
+};
+
+/** A rich document. */
+export declare interface RichDocument {
+    readonly type: 'doc';
+    readonly blocks: ReadonlyArray<RichBlock>;
+}
+
+export declare const RichDocumentEditor: (props: RichDocumentEditorProps) => ReactNode;
+
+export declare interface RichDocumentEditorProps extends WidgetProps {
+    readonly renderPicker?: RichDocumentPicker;
+    /** Renders inside one block's group, after its actions — its comments, say.
+     *  `blockId` is the block's stable id (it survives moves and new revisions);
+     *  `label` names it as its legend does (`Paragraph 2`). */
+    readonly renderBlockAside?: (blockId: string, label: string) => ReactNode;
+    /** The words of the controls; English by default (see `ContentFormStrings`). */
+    readonly strings?: ContentFormStringsInput;
+    /**
+     * How a paragraph's or a heading's text is edited: `markup` (default) is a
+     * text area with the small inline syntax; `visual` edits it as it looks —
+     * bold as bold, links as links — with Bold and Italic buttons. Lists and
+     * tables keep their lines either way.
+     */
+    readonly surface?: 'markup' | 'visual';
+}
+
+/** Translate a Contentful rich-text document, and say what could not be translated. */
+export declare const richDocumentFromContentful: (root: ContentfulNode | null | undefined, options?: ContentfulImportOptions) => ContentfulImportResult;
+
+/**
+ * Translate HTML into a rich document, and say what could not be translated.
+ * Links resolve through `resolveLink`; everything else is text or a finding.
+ */
+export declare const richDocumentFromHtml: (html: string, options?: HtmlImportOptions) => HtmlImportResult;
+
+/** Renders a control that picks one document of `type`. */
+export declare type RichDocumentPicker = (props: {
+    readonly id: string;
+    readonly type: string;
+    readonly value: string;
+    readonly onChange: (documentId: string) => void;
+}) => ReactNode;
+
+/** One problem with a rich document, at a path below the field. */
+export declare interface RichDocumentProblem {
+    readonly path: string;
+    readonly rule: string;
+    readonly message: string;
+}
+
+/** Everything wrong with `value` as a rich document under `options`. */
+export declare const richDocumentProblems: (path: string, value: unknown, options: RichTextOptions) => ReadonlyArray<RichDocumentProblem>;
+
+/** A document reference found in a rich document. */
+export declare interface RichDocumentReference {
+    readonly path: string;
+    readonly targetType: string;
+    readonly targetDocumentId: string;
+}
+
+/** Every image and link reference in a (valid) document, with its path. */
+export declare const richDocumentReferences: (path: string, doc: RichDocument, options: RichTextOptions) => ReadonlyArray<RichDocumentReference>;
+
+/** The document's blocks, in order. Renders nothing for a value that is not a rich document. */
+export declare const RichDocumentView: ({ document, hrefOf, renderImage }: RichDocumentViewProps) => ReactNode;
+
+export declare interface RichDocumentViewProps {
+    /** A stored `Schema.RichText()` value (a plain string renders as paragraphs). */
+    readonly document: unknown;
+    /** The address of a linked document, or undefined when it has none (not live). */
+    readonly hrefOf?: (documentId: string) => string | undefined;
+    /** Render an image block; without it, images are left out. */
+    readonly renderImage?: (block: {
+        readonly asset: string;
+        readonly caption?: string;
+    }) => ReactNode;
+}
+
+/** A run of text inside a block. */
+export declare type RichInline = {
+    readonly type: 'text';
+    readonly text: string;
+    readonly marks?: ReadonlyArray<RichMark>;
+}
+/** A link to a document (by its documentId) — the site resolves its address. */
+| {
+    readonly type: 'link';
+    readonly target: string;
+    readonly text: string;
+};
+
+/** An inline mark. */
+export declare type RichMark = 'bold' | 'italic' | 'underline';
+
+/**
+ * Which resources a rich-text field may hold: `images` names the content type
+ * an image block references (an asset type), `links` the type a link
+ * references (a page type). Unset → that node is not allowed.
  */
 export declare interface RichTextOptions {
-    readonly allowImages?: boolean;
-    readonly allowEmbeds?: boolean;
+    readonly images?: string;
+    readonly links?: string;
+}
+
+export declare const RichTextSurface: (props: RichTextSurfaceProps) => ReactNode;
+
+export declare interface RichTextSurfaceProps {
+    readonly id: string;
+    /** The id of the element naming the text box (its label). */
+    readonly labelledBy: string;
+    readonly content: ReadonlyArray<RichInline>;
+    readonly onChange: (content: ReadonlyArray<RichInline>) => void;
+    /** The words of the mark buttons, and their accessible names. */
+    readonly words: {
+        readonly bold: string;
+        readonly italic: string;
+        readonly underline: string;
+    };
 }
 
 /**
@@ -272,7 +1439,10 @@ export declare const Schema: {
     /** Single-line text. `.pipe(maxLength(N>120))` switches it to a textarea. */
     readonly String: PipeableField;
     /** Numeric input. */
+    /** A whole number (an integer column); a fraction is refused on save. */
     readonly Number: PipeableField;
+    /** A number with a fractional part (a `real` column), e.g. a focal point's 0.25. */
+    readonly Fraction: PipeableField;
     /** Toggle. */
     readonly Boolean: PipeableField;
     /** Date-only picker. */
@@ -285,10 +1455,12 @@ export declare const Schema: {
     /** Closed value set → `<select>` widget + a CHECK constraint. */
     readonly Literal: (values_0: string, ...values: string[]) => PipeableField;
     /**
-     * Rich text, stored as a JSON document (e.g. a TipTap doc). The shipped
-     * default widget is a plain textarea placeholder — swap in a real editor
-     * via the `ContentForm` `widgets` override. `allowImages` /
-     * `allowEmbeds: false` reject that content class at save time.
+     * Rich text, stored as a `RichDocument` (see richDocument.ts): blocks with
+     * stable ids — paragraph, heading, list, table, image — and inline text
+     * with marks and links. `images` / `links` name the content types an image
+     * block and a link reference; unset, that node is refused at save time. A
+     * plain string is saved as paragraphs. The editor widget is
+     * `RichDocumentEditor`.
      */
     readonly RichText: (options?: RichTextOptions) => PipeableField;
     /**
@@ -305,11 +1477,184 @@ export declare const Schema: {
     readonly Array: (element: FieldSchema) => PipeableField;
     /** Nested object. Stored as a JSON document. */
     readonly Struct: (fields: Readonly<Record<string, FieldSchema>>) => PipeableField;
+    /**
+     * An ordered list of placed components (ADR-CMS-015), stored as a JSON array
+     * of `ComponentInstance`. Only the listed definitions may be placed; each
+     * instance's props are validated against its definition on save.
+     */
+    readonly Components: (definitions: ReadonlyArray<ComponentDefinition>) => PipeableField;
 };
 
-/** The canonical slug helper: lowercase, hyphenate, strip non-url chars. */
+/** What makes a type findable. */
+declare interface SearchConfig {
+    /** The string field ranked first — usually the title. */
+    readonly title: string;
+}
+
+/** What is wrong with values for a manifest's settings; empty when nothing is. Unknown keys are refused. */
+export declare const settingsProblems: (manifest: CmsExtensionManifest, values: Readonly<Record<string, unknown>>) => ReadonlyArray<string>;
+
+/** The settings with their defaults filled in, dropping keys the manifest no longer has. */
+export declare const settingsWithDefaults: (manifest: CmsExtensionManifest, stored: Readonly<Record<string, unknown>>) => Readonly<Record<string, ExtensionSettingValue>>;
+
+export declare interface SitemapUrl extends PageAlternate {
+    readonly documentId: string;
+    /** ISO date of the variant's last change, when known. */
+    readonly lastmod: string | null;
+    /** The document in every language it has its own variant in, this one included. */
+    readonly alternates: ReadonlyArray<PageAlternate>;
+}
+
+/**
+ * Every page the sitemap lists: each language's own variants (never a
+ * fallback), those `include` accepts (leave out pages not for search
+ * engines), with their alternates.
+ */
+export declare const sitemapUrls: (trees: ReadonlyArray<LocalizedTree>, include?: (node: TreeNode) => boolean) => ReadonlyArray<SitemapUrl>;
+
+/**
+ * The sitemap document. `href(locale, path)` makes a page's absolute URL;
+ * `xDefault` names the language an unmatched reader gets.
+ */
+export declare const sitemapXml: (urls: ReadonlyArray<SitemapUrl>, href: (locale: string, path: string) => string, xDefault?: string) => string;
+
+/**
+ * The canonical slug helper: lowercase, letters with accents folded to their
+ * base letter (umlauts spelled out, `ß` as `ss`), hyphenate, strip every
+ * other non-url character.
+ */
 export declare const slugify: (value: unknown) => string;
 
+/** Mark an element of the preview with the field path it renders. */
+export declare const sourceAttributes: (path: string) => {
+    readonly "data-cms-source": string;
+};
+
+/** The field path behind a clicked element of the preview, or null. */
+export declare const sourcePathOf: (target: unknown) => string | null;
+
+/** A type's taxonomy — see `ContentTypeSpec.taxonomy`. */
+export declare interface TaxonomyConfig {
+    /** A declared `Schema.Array(Schema.String)` field. */
+    readonly field: string;
+    readonly terms: ReadonlyArray<VocabularyTerm>;
+    /** A term outside the vocabulary: `refuse` (default) fails the save, `keep` keeps it as typed. */
+    readonly unknown?: 'refuse' | 'keep';
+}
+
+/** The value a save stores: the normalised terms, then the unknown ones (refused by validation unless kept). */
+export declare const taxonomyValue: (config: Pick<TaxonomyConfig, "terms">, input: ReadonlyArray<unknown>) => ReadonlyArray<string>;
+
+/** The template a row names, if any (undefined for none, null for an unknown id). */
+export declare const templateOf: (type: Typed, row: Readonly<Record<string, unknown>>) => PageTemplate | null | undefined;
+
+/** Declared on a content type as `templates`. */
+export declare interface TemplatesConfig {
+    /** An optional string field that stores the template's id. */
+    readonly field: string;
+    /** The `Schema.Components` field the rules apply to. */
+    readonly components: string;
+    readonly list: ReadonlyArray<PageTemplate>;
+}
+
+/**
+ * The values a new document built from `templateId` starts with: the
+ * template's id, its preset values and its components (the save stamps each
+ * component's instance id). Null for an unknown template.
+ */
+export declare const templateValues: (type: Typed, templateId: string) => Record<string, unknown> | null;
+
+/** Where a row breaks the rules of the template it names. Empty when it keeps them. */
+export declare const templateViolations: (type: Typed, row: Readonly<Record<string, unknown>>) => ReadonlyArray<FieldViolation>;
+
+/**
+ * Put `mark` on the text in `[start, end)`, or take it off when all of it
+ * already carries it. Text runs are split at the edges; a link is left as it
+ * is (a link carries no marks).
+ */
+export declare const toggleMark: (content: ReadonlyArray<RichInline>, start: number, end: number, mark: RichMark) => ReadonlyArray<RichInline>;
+
+export declare interface ToolExposure {
+    readonly tool: string;
+    readonly state: 'on' | 'off' | 'locked';
+    /** The step of the chain that decided it; null for the site's default. */
+    readonly decidedAt: number | null;
+}
+
+/** An XLIFF 2.1 core document for one file. */
+export declare const toXliff: (exchange: XliffExchange) => string;
+
+export declare interface TranslationUnit {
+    /** Where the text lives: `title`, `body/<blockId>`, `body/<blockId>/<item>`,
+     *  `body/<blockId>/<row>.<cell>`, `body/<blockId>/caption`,
+     *  `sections/<instanceId>/<prop>`. */
+    readonly id: string;
+    readonly source: string;
+    /** The translation, when there is one. */
+    readonly target?: string;
+    /** XLIFF segment state. */
+    readonly state?: 'initial' | 'translated' | 'reviewed' | 'final';
+}
+
+/** The translatable text of a document's values, one unit per piece, in field order. Empty text is left out. */
+export declare const translationUnits: (fields: Readonly<Record<string, FieldSchema>>, values: Readonly<Record<string, unknown>>, prefix?: string) => ReadonlyArray<TranslationUnit>;
+
+/** How a content type forms a tree. Validated by `defineContentType`. */
+export declare interface TreeConfig {
+    /** An optional `Schema.Reference(<this type>)` field: the parent document. */
+    readonly parent: string;
+    /** An optional number field ordering siblings (ascending; unset sorts last). */
+    readonly order?: string;
+    /** The string field that is this node's path segment — usually the slug. */
+    readonly segment: string;
+    /**
+     * Optional fields a page takes from the nearest ancestor that sets them
+     * (a header, a footer): read with {@link inheritedValue}. `locked: true`
+     * means no page may set it — only whatever the app supplies above the
+     * tree (a site default).
+     */
+    readonly inherit?: Readonly<Record<string, InheritRule>>;
+}
+
+/** One published variant offered to {@link buildTree}. */
+export declare interface TreeEntry {
+    readonly row: Row;
+    readonly locale: string;
+    readonly fallback: boolean;
+}
+
+/** One published document placed in the tree. */
+export declare interface TreeNode {
+    readonly documentId: string;
+    /** The parent's documentId; null at the root. */
+    readonly parent: string | null;
+    /** 0 at the root. */
+    readonly depth: number;
+    /** The segments from the root down to this node. */
+    readonly segments: ReadonlyArray<string>;
+    /** `segments` joined with `/`. */
+    readonly path: string;
+    /** The published variant that answers for this document. */
+    readonly row: Row;
+    /** The locale of `row`. */
+    readonly locale: string;
+    /** True when `row` is a fallback locale's variant. */
+    readonly fallback: boolean;
+}
+
+declare type Typed = {
+    readonly name: string;
+    readonly fields: Readonly<Record<string, FieldSchema>>;
+    readonly templates?: TemplatesConfig;
+};
+
+/** Undo the last step: the form to show, and the history after it; null when there is nothing to undo. */
+export declare const undoEdit: (history: EditHistory, current: Readonly<Record<string, unknown>>) => {
+    readonly history: EditHistory;
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly label: string;
+} | null;
+
 /**
  * Mark a string field unique PER TENANT. The derived `<type>_drafts` +
  * `<type>_published` tables get a real composite `(tenantId, <field>)`
@@ -320,13 +1665,51 @@ export declare const slugify: (value: unknown) => string;
  */
 export declare const unique: () => FieldRefinement;
 
+/** A stable fingerprint of the units' ids and source text — the import checks the source has not changed since. */
+export declare const unitsHash: (units: ReadonlyArray<TranslationUnit>) => string;
+
 /**
  * Validate a row against a content type's save-time rules. Throws
  * `ContentValidationFailed` carrying EVERY violation (per-field detail)
  * when any rule breaks; returns nothing on success. The throwing face of
  * `contentViolations` — `saveDraft` calls this after derivation.
  */
-export declare const validateContent: (type: Pick<ContentType, "name" | "fields">, row: Readonly<Record<string, unknown>>) => void;
+export declare const validateContent: (type: Pick<ContentType, "name" | "fields"> & Partial<Pick<ContentType, "taxonomy">>, row: Readonly<Record<string, unknown>>) => void;
+
+/**
+ * A field's value as the text a person compares: a rich document's text (one
+ * line per block), a component list one line per component with its text
+ * props, a date as its ISO time, anything else structured as compact JSON.
+ */
+export declare const valueText: (value: unknown) => string;
+
+export declare const VISUAL_EDITING_PROTOCOL = "voltro.cms.visual/1";
+
+/** A message for the other side of `session`. */
+export declare const visualMessage: <M extends {
+    readonly kind: string;
+}>(session: VisualSession, message: M) => M & {
+    protocol: typeof VISUAL_EDITING_PROTOCOL;
+    nonce: string;
+};
+
+/** A message event as far as these checks read it. */
+export declare interface VisualMessageEvent {
+    readonly origin: string;
+    readonly data: unknown;
+}
+
+/** Who may talk: the one origin, with the nonce of this session. */
+export declare interface VisualSession {
+    readonly origin: string;
+    readonly nonce: string;
+}
+
+/** One term and the spellings that mean it. */
+export declare interface VocabularyTerm {
+    readonly term: string;
+    readonly synonyms?: ReadonlyArray<string>;
+}
 
 export declare type Widget = (props: WidgetProps) => ReactNode;
 
@@ -335,10 +1718,48 @@ export declare const widgetFor: (hint: EditorHint, overrides?: Partial<Record<Ed
 
 /** Props for a single field widget. */
 export declare interface WidgetProps {
+    /** The control's element id — the field's `<label>` points at it, so a
+     *  widget that renders its own control must put it on that control. */
+    readonly id: string;
     readonly name: string;
     readonly field: FieldSchema;
     readonly value: unknown;
     readonly onChange: (value: unknown) => void;
 }
 
+/** A component withheld for want of consent: which purpose would release it. */
+export declare interface WithheldInstance {
+    readonly instanceId: string;
+    readonly componentId: string;
+    readonly consentRequired: string;
+    readonly props: Readonly<Record<string, never>>;
+}
+
+export declare interface XliffExchange {
+    readonly srcLang: string;
+    readonly trgLang: string;
+    /** The `<file id>` — which document and revision this is. */
+    readonly fileId: string;
+    /** `<note category>` → text: what the importer checks (source hash, type, revision). */
+    readonly notes: Readonly<Record<string, string>>;
+    readonly units: ReadonlyArray<TranslationUnit>;
+}
+
+/** An XLIFF file that cannot be read, or would be unsafe to. */
+export declare class XliffInvalid extends Error {
+    readonly reason: string;
+    readonly _tag = "XliffInvalid";
+    constructor(reason: string);
+}
+
+/**
+ * The instant a local wall time means in `zone`. A wall time in a gap moves
+ * to the first moment after it (`gap`); one in a fold takes the earlier of
+ * its two instants (`fold`).
+ */
+export declare const zonedInstant: (local: string, zone: string) => {
+    readonly instant: Date;
+    readonly adjusted?: "gap" | "fold";
+};
+
 export { }