@voltro/cms 0.83.1 → 0.85.0

package/dist/web.d.ts

@@ -1,10 +1,19 @@
 import { ReactNode } from 'react';
 import { Row } from '@voltro/database';
 import { Schema as Schema_2 } from 'effect';
+import { YieldableError } from 'effect/Cause';
 
 /** A document's address in every language it has its own variant in. */
 export declare const alternatesOf: (trees: ReadonlyArray<LocalizedTree>, documentId: string) => ReadonlyArray<PageAlternate>;
 
+export declare type AppliedSelection = {
+    readonly ok: true;
+    readonly values: Readonly<Record<string, unknown>>;
+} | {
+    readonly ok: false;
+    readonly reason: 'otherIntent' | 'otherDocument' | 'revisionMoved' | 'targetGone';
+};
+
 /**
  * Compute every `derivedFrom` field from its source value. Returns a NEW
  * row — the input is not mutated. A caller-provided value for a derived
@@ -15,6 +24,19 @@ export declare const alternatesOf: (trees: ReadonlyArray<LocalizedTree>, documen
  */
 export declare const applyDerivations: (type: Pick<ContentType, "fields" | "derivedFields"> & Partial<Pick<ContentType, "taxonomy">>, row: Readonly<Record<string, unknown>>) => Record<string, unknown>;
 
+/**
+ * The values with the answer applied where the intent said: a field takes the
+ * chosen document; a placed component's prop takes it; an image block takes it
+ * as its asset; a paragraph or a heading gets a link to it over the selected
+ * text. Refused for another intent, another document or form, a revision that
+ * moved on, or a block or component that is gone.
+ */
+export declare const applySelection: (values: Readonly<Record<string, unknown>>, intent: SelectionIntent, answer: SelectionAnswer, now: {
+    readonly documentId?: string | null;
+    readonly revisionId?: string | null;
+    readonly formId?: string;
+}) => AppliedSelection;
+
 /**
  * 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
@@ -22,6 +44,18 @@ export declare const applyDerivations: (type: Pick<ContentType, "fields" | "deri
  */
 export declare const applyTranslation: (fields: Readonly<Record<string, FieldSchema>>, source: Readonly<Record<string, unknown>>, units: ReadonlyArray<TranslationUnit>) => Record<string, unknown>;
 
+/**
+ * Attribute per-day values (`YYYY-MM-DD`, UTC) to the revision live at the end
+ * of each day. A day when nothing was live is left out (`unattributed`).
+ */
+export declare const attributeToRevisions: (timeline: ReadonlyArray<LiveStretch>, daily: ReadonlyArray<{
+    readonly day: string;
+    readonly value: number;
+}>) => {
+    readonly shares: ReadonlyArray<RevisionShare>;
+    readonly unattributed: number;
+};
+
 export declare interface Audience {
     readonly id: string;
     /** Raise it when the rule changes meaning; a variant records the version it was written for. */
@@ -56,8 +90,26 @@ declare interface AvailabilityConfig {
     readonly until?: string;
     /** A boolean field: `true` withdraws the document at once. */
     readonly blocked?: string;
+    /** A date or datetime field: usable from this moment on. */
+    readonly from?: string;
+    /** A list-of-text field of territory codes (ISO 3166-1 alpha-2): usable only there. Empty: everywhere. */
+    readonly territories?: string;
+    /** A list-of-text field of channels (`web`, `app`, `print`, …): usable only on these. Empty: on every channel. */
+    readonly channels?: string;
+    /** A list-of-text field of purposes (`editorial`, `advertising`, …): usable only for these. Empty: for every purpose. */
+    readonly purposes?: string;
 }
 
+/** Whether a block, or any text in it, holds a suggestion. */
+export declare const blockHasChanges: (block: RichBlock) => boolean;
+
+/**
+ * The markup a block is edited as: text blocks are one run, a list one line
+ * per item (two spaces of indent per level), a table one line per row with
+ * cells split by `|`; an image or a component has none.
+ */
+export declare const blockMarkup: (block: RichBlock) => 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
@@ -65,9 +117,77 @@ declare interface AvailabilityConfig {
  */
 export declare const buildTree: (entries: ReadonlyArray<TreeEntry>, config: TreeConfig) => CmsTree;
 
+/** What a route's response depends on — declared once, read by every cache in front of it. */
+export declare interface CacheContract {
+    /** The route pattern (`/v1/site/page`), the purge selector's route class. */
+    readonly route: string;
+    readonly query?: ReadonlyArray<QueryParam>;
+    /** The language, from a bounded set — never the raw `Accept-Language`. */
+    readonly locale?: CacheDimension;
+    /** Declared audiences or experiment cohorts the output differs by. */
+    readonly audience?: CacheDimension;
+    /** The reader's consent decision class — only when the output really varies by it. */
+    readonly consent?: CacheDimension;
+    /** Cookies and headers that make a response private when present (a session, a preview token). */
+    readonly credentials?: ReadonlyArray<string>;
+    /** The most variants one route may fan out to. Default 64. */
+    readonly cardinalityBudget?: number;
+}
+
+/** A bounded request dimension: where it is read from, and its values. */
+export declare interface CacheDimension {
+    /** A request header (lowercase) or a cookie (`cookie:<name>`). */
+    readonly from: string;
+    readonly values: ReadonlyArray<string>;
+    /** Taken when the request names none, or one not in `values`. */
+    readonly fallback: string;
+}
+
+export declare type CacheIdentity = {
+    readonly cacheable: true;
+    /** The canonical identity — every dimension in a fixed order. */
+    readonly key: string;
+    /** A short, stable fingerprint of `key`. */
+    readonly fingerprint: string;
+    readonly vary: ReadonlyArray<string>;
+    /** What a purge of this response names: the route class and its tags. */
+    readonly purge: {
+        readonly route: string;
+        readonly tags: ReadonlyArray<string>;
+    };
+    readonly variants: number;
+    readonly explain: ReadonlyArray<ExplainLine>;
+} | {
+    readonly cacheable: false;
+    readonly reason: 'method' | 'credential' | 'path' | 'budget';
+    readonly detail: string;
+    /** A refused or private request is never stored by a shared cache. */
+    readonly cacheControl: 'private, no-store';
+    readonly explain: ReadonlyArray<ExplainLine>;
+};
+
+export declare interface CacheRequest {
+    readonly method: string;
+    readonly host: string;
+    /** The path as received, still encoded. */
+    readonly path: string;
+    /** The query string without `?`. */
+    readonly query: string;
+    readonly headers: Readonly<Record<string, string | undefined>>;
+}
+
+/** Who suggests the edit, and when; `id` names the change. */
+export declare type ChangeAuthor = Omit<RichChange, 'kind'>;
+
+/** What to do with one suggestion. */
+export declare type ChangeDecision = 'accept' | 'reject' | 'keep';
+
 /** 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 for a vendor origin that is not exactly `https://host[:port]` — it would widen the policy. */
+export declare const checkConsentPurposes: (purposes: ReadonlyArray<ConsentPurpose>) => void;
+
 /** 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;
 
@@ -86,6 +206,20 @@ export declare interface CmsExtensionManifest {
     readonly settings?: ReadonlyArray<ExtensionSetting>;
 }
 
+/**
+ * Where a content row lives besides its tenant: the site it belongs to, the
+ * content environment (e.g. `production`, `staging`) and its locale. Three
+ * separate axes, stored on every draft, published row and revision, and
+ * required by every write and read — never taken from a caller's free-form
+ * filter. The tenant comes from the request subject (`tenant()`).
+ */
+declare interface CmsScope {
+    readonly site: string;
+    readonly environment: string;
+    /** A BCP 47 tag, e.g. `en-GB`. */
+    readonly locale: string;
+}
+
 /** A built tree: every routable node, depth-first, siblings in order. */
 export declare interface CmsTree {
     readonly nodes: ReadonlyArray<TreeNode>;
@@ -103,6 +237,19 @@ export declare type CmsWriteError = ContentValidationFailed | ContentNotFound |
 /** Order of two `major.minor.patch` versions: negative, 0 or positive. */
 export declare const compareVersions: (a: string, b: string) => number;
 
+/**
+ * The identity of `request` under `contract` at publication `checkpoint` (a
+ * release or publication id), with the document tags its response depends on.
+ */
+export declare const compileCacheIdentity: (contract: CacheContract, request: CacheRequest, context: {
+    readonly checkpoint: string;
+    readonly tags?: ReadonlyArray<string>;
+}) => CacheIdentity;
+
+declare type ComponentBlock = Extract<RichBlock, {
+    readonly type: 'component';
+}>;
+
 /**
  * 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
@@ -114,10 +261,29 @@ export declare interface ComponentDefinition {
     readonly displayName: string;
     readonly props: Readonly<Record<string, FieldSchema>>;
     readonly fingerprint: string;
+    /** What it is for, in an editor's words — searched by the picker. */
+    readonly description?: string;
+    /** The editorial jobs it serves (`'announce an event'`, `'collect leads'`) — the picker groups and searches by them. */
+    readonly jobs?: ReadonlyArray<string>;
+    /** Named presets an editor starts from (`dark`, `compact`): props that differ from empty. */
+    readonly variants?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    /** Example props — previews, galleries and tests render them; checked against `props` when a content type uses the component. */
+    readonly fixtures?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    /** Upgrades of instances saved against an earlier definition: its fingerprint → the props it becomes now. */
+    readonly migrations?: Readonly<Record<string, (props: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>>>>;
     /** The consent purpose a reader must grant before this component's props reach them (`gateConsent`). */
     readonly consent?: string;
 }
 
+/** A component's fixtures and variants against its props: every violation, with the fixture or variant it is in. */
+export declare const componentExampleViolations: (definition: ComponentDefinition) => ReadonlyArray<FieldViolation>;
+
+/** The fingerprint a component with these props has — to key a migration from an earlier definition. */
+export declare const componentFingerprint: (spec: {
+    readonly id: string;
+    readonly props: Readonly<Record<string, FieldSchema | PipeableField>>;
+}) => string;
+
 /** One placed component in a `components` field, as stored. */
 export declare interface ComponentInstance {
     /** Stable across saves, reorders and translations of the same placement. */
@@ -131,6 +297,17 @@ export declare interface ComponentInstance {
 /** A reader's choices: purpose id → the version they allowed. */
 export declare type ConsentChoices = Readonly<Record<string, number>>;
 
+/**
+ * The same decision as {@link gateConsent}, for the browser to enforce: a
+ * Content-Security-Policy whose `frame-src` lets in only this origin and the
+ * vendors the reader granted. Set it on the response (a web middleware) and
+ * an embed the reader refused cannot load even if one slipped into the page.
+ */
+export declare const consentContentSecurityPolicy: (purposes: ReadonlyArray<ConsentPurpose>, choices: ConsentChoices, base?: string) => string;
+
+/** The origins of the vendors whose purpose the reader granted in its current version. */
+export declare const consentedOrigins: (purposes: ReadonlyArray<ConsentPurpose>, choices: ConsentChoices) => ReadonlyArray<string>;
+
 /** Something a reader can allow or refuse. */
 export declare interface ConsentPurpose {
     readonly id: string;
@@ -138,8 +315,31 @@ export declare interface ConsentPurpose {
     readonly version: number;
     readonly displayName: string;
     readonly description: string;
+    /** The third parties it lets in (none for a first-party purpose). */
+    readonly vendors?: ReadonlyArray<ConsentVendor>;
+}
+
+/**
+ * A third party a purpose lets in — kept apart from the purpose itself: who
+ * it is, where its content comes from (the origins a page may then load), what
+ * it stores on the reader's device, and what it does with the data.
+ */
+export declare interface ConsentVendor {
+    /** camelCase, unique within the purpose — what a reader-facing text is keyed by. */
+    readonly id: string;
+    readonly name: string;
+    /** `https://host` origins, exactly — the browser loads frames from them once the purpose is granted. */
+    readonly origins: ReadonlyArray<string>;
+    readonly storage: string;
+    readonly dataUse: string;
 }
 
+/** The `href` of a one-off contact: `mailto:` an address, `tel:` a number without its spacing. */
+export declare const contactLiteralHref: (channel: "email" | "phone", value: string) => string;
+
+/** Why `value` is not a usable one-off e-mail address or phone number, or null when it is. */
+export declare const contactLiteralProblem: (channel: "email" | "phone", value: string) => string | null;
+
 export declare const CONTENT_FORM_STRINGS: ContentFormStrings;
 
 /**
@@ -189,6 +389,11 @@ export declare interface ContentFormProps {
     readonly strings?: ContentFormStringsInput;
     /** How rich text's paragraphs and headings are edited — see `RichDocumentEditorProps.surface`. */
     readonly richTextSurface?: 'markup' | 'visual';
+    /**
+     * Where each field's value lives, for its widget's `target`; by default the
+     * field itself. A placed component's props form names its instance and prop.
+     */
+    readonly widgetTarget?: (name: string) => WidgetTarget;
 }
 
 export declare interface ContentFormStrings {
@@ -204,6 +409,11 @@ export declare interface ContentFormStrings {
     readonly add: string;
     readonly addBlock: string;
     readonly addComponent: string;
+    /** The search above the component picker. */
+    readonly findComponent: string;
+    readonly noComponentFound: string;
+    /** The group of components that name no job. */
+    readonly otherComponents: string;
     readonly unknownComponent: (componentId: string) => string;
     readonly level: string;
     readonly numbered: string;
@@ -211,6 +421,10 @@ export declare interface ContentFormStrings {
     readonly numberedAt: (depth: number) => string;
     readonly headerRow: string;
     readonly image: string;
+    /** The label of a download block's file. */
+    readonly file: string;
+    /** The label of the text a download block's link shows. */
+    readonly fileLabel: string;
     readonly caption: string;
     readonly text: string;
     readonly listItems: string;
@@ -226,6 +440,27 @@ export declare interface ContentFormStrings {
     readonly bold: string;
     readonly italic: string;
     readonly underline: string;
+    /** A block's or a selection's named style (a rich-text profile's styles). */
+    readonly style: string;
+    readonly noStyle: string;
+    /** Which component a component block places. */
+    readonly component: string;
+    /** The contact inserter: a published contact point, or a one-off address or number. */
+    readonly contactKind: string;
+    readonly contactPoint: string;
+    readonly contactEmail: string;
+    readonly contactPhone: string;
+    readonly contactValue: string;
+    readonly contactText: string;
+    readonly insertContact: string;
+    /** Above a block holding suggested changes; it is edited again once they are decided. */
+    readonly suggestedChanges: string;
+    /** One suggestion: who made it, what it puts in and takes out. */
+    readonly changeBy: (by: string, inserted: string, deleted: string) => string;
+    readonly accept: string;
+    readonly reject: string;
+    readonly acceptLabel: (by: string) => string;
+    readonly rejectLabel: (by: string) => string;
 }
 
 /** The defaults with an app's words over them. */
@@ -281,13 +516,11 @@ export declare interface ContentfulNode {
 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;
+declare const ContentGone_base: Schema_2.Class<ContentGone, Schema_2.TaggedStruct<"ContentGone", {
+    readonly contentType: Schema_2.String;
     /** The address asked for. */
-    path: typeof Schema_2.String;
-}>;
+    readonly path: Schema_2.String;
+}>, YieldableError>;
 
 /**
  * Raised by `saveDraft` when the caller supplies an explicit `id` that
@@ -298,12 +531,10 @@ declare const ContentGone_base: Schema_2.TaggedErrorClass<ContentGone, "ContentG
 export declare class ContentIdConflict extends ContentIdConflict_base {
 }
 
-declare const ContentIdConflict_base: Schema_2.TaggedErrorClass<ContentIdConflict, "ContentIdConflict", {
-    readonly _tag: Schema_2.tag<"ContentIdConflict">;
-} & {
-    contentType: typeof Schema_2.String;
-    id: typeof Schema_2.String;
-}>;
+declare const ContentIdConflict_base: Schema_2.Class<ContentIdConflict, Schema_2.TaggedStruct<"ContentIdConflict", {
+    readonly contentType: Schema_2.String;
+    readonly id: Schema_2.String;
+}>, YieldableError>;
 
 /**
  * Raised by `publish` / `unpublish` / `archive` when the row id doesn't
@@ -314,16 +545,14 @@ declare const ContentIdConflict_base: Schema_2.TaggedErrorClass<ContentIdConflic
 export declare class ContentNotFound extends ContentNotFound_base {
 }
 
-declare const ContentNotFound_base: Schema_2.TaggedErrorClass<ContentNotFound, "ContentNotFound", {
-    readonly _tag: Schema_2.tag<"ContentNotFound">;
-} & {
-    contentType: typeof Schema_2.String;
-    id: typeof Schema_2.String;
+declare const ContentNotFound_base: Schema_2.Class<ContentNotFound, Schema_2.TaggedStruct<"ContentNotFound", {
+    readonly contentType: Schema_2.String;
+    readonly id: Schema_2.String;
     /** 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"]>;
-}>;
+    readonly stage: Schema_2.Literals<readonly ["draft", "published", "revision", "share"]>;
+}>, YieldableError>;
 
 /** A registered content type. */
 declare interface ContentType {
@@ -343,6 +572,7 @@ declare interface ContentType {
     /** Whether publishing needs an approved revision — see `ContentTypeSpec.review`. */
     readonly review?: {
         readonly required: boolean | 'workspace';
+        readonly workflow?: ReviewWorkflow;
     };
     /** When documents may be used — see `ContentTypeSpec.availability`. */
     readonly availability?: AvailabilityConfig;
@@ -392,10 +622,15 @@ declare interface ContentTypeSpec {
      * (`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.
+     * `team.reviewRequired`) — register `cmsTeamTable` too. With `workflow`
+     * (`defineReviewWorkflow`), the approval is a workflow instance that
+     * approved the exact revision — every applicable step decided — instead of
+     * one approval; register `cmsWorkflowInstancesTable` and
+     * `cmsWorkflowDecisionsTable`.
      */
     readonly review?: {
         readonly required: boolean | 'workspace';
+        readonly workflow?: ReviewWorkflow;
     };
     /**
      * When this type's documents may be used (`until`: a date/datetime field,
@@ -477,16 +712,14 @@ declare interface ContentTypeSpec {
 export declare class ContentValidationFailed extends ContentValidationFailed_base {
 }
 
-declare const ContentValidationFailed_base: Schema_2.TaggedErrorClass<ContentValidationFailed, "ContentValidationFailed", {
-    readonly _tag: Schema_2.tag<"ContentValidationFailed">;
-} & {
-    contentType: typeof Schema_2.String;
-    violations: Schema_2.Array$<Schema_2.Struct<{
-        field: typeof Schema_2.String;
-        rule: typeof Schema_2.String;
-        message: typeof Schema_2.String;
+declare const ContentValidationFailed_base: Schema_2.Class<ContentValidationFailed, Schema_2.TaggedStruct<"ContentValidationFailed", {
+    readonly contentType: Schema_2.String;
+    readonly violations: Schema_2.$Array<Schema_2.Struct<{
+        readonly field: Schema_2.String;
+        readonly rule: Schema_2.String;
+        readonly message: Schema_2.String;
     }>>;
-}>;
+}>, YieldableError>;
 
 export declare type ContentValue = Record<string, unknown>;
 
@@ -510,21 +743,67 @@ export declare type ContentValue = Record<string, unknown>;
  */
 export declare const contentViolations: (type: Pick<ContentType, "name" | "fields"> & Partial<Pick<ContentType, "taxonomy">>, row: Readonly<Record<string, unknown>>) => ReadonlyArray<FieldViolation>;
 
+/** How many variants the contract allows at most (query strings count as unbounded beyond the budget). */
+export declare const contractVariants: (contract: CacheContract) => number;
+
 /** Decode character references (`&amp;`, `&#8217;`, `&#x2014;`). */
 export declare const decodeEntities: (text: string) => string;
 
+/** The intent a `?select=…` value carries, or null. */
+export declare const decodeSelectionIntent: (value: string | null | undefined) => SelectionIntent | null;
+
 /** 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;
+    /** What it is for, in an editor's words. */
+    readonly description?: string;
+    /** The editorial jobs it serves; the picker groups and searches by them. */
+    readonly jobs?: ReadonlyArray<string>;
+    readonly variants?: ComponentDefinition["variants"];
+    readonly fixtures?: ComponentDefinition["fixtures"];
+    readonly migrations?: ComponentDefinition["migrations"];
 }) => ComponentDefinition;
 
+/**
+ * Declare the design tokens components may name (`Schema.Token(tokens, 'tone')`).
+ * Group and token names are camelCase; the values are what an editor reads
+ * beside each name — the renderer owns the actual styles.
+ */
+export declare const defineDesignTokens: <T extends DesignTokens>(tokens: T) => T;
+
+/** Declare a metric; the fingerprint follows its meaning. */
+export declare const defineMetric: (spec: MetricSpec) => MetricDefinition;
+
+/**
+ * Declare what a rich-text field allows (`Schema.RichText({ profile })`):
+ * its blocks, heading levels and marks, named styles from one design-token
+ * group, the components that may sit between blocks, and how e-mail
+ * addresses and phone numbers are given — a published contact point of
+ * `contactPoints`, and/or a one-off checked on save (`contactLiterals`).
+ * Bump `version` when it changes: a saved document records `<name>@<version>`.
+ * Unset lists allow every built-in block, heading level and mark.
+ */
+export declare const defineRichTextProfile: (spec: {
+    readonly name: string;
+    readonly version: number;
+    readonly blocks?: ReadonlyArray<Exclude<RichBlockKind, "component">>;
+    readonly headings?: ReadonlyArray<2 | 3>;
+    readonly marks?: ReadonlyArray<RichMark>;
+    readonly styles?: {
+        readonly tokens: DesignTokens;
+        readonly group: string;
+    };
+    readonly components?: ReadonlyArray<ComponentDefinition>;
+    readonly contactPoints?: string;
+    readonly contactLiterals?: boolean;
+}) => RichTextProfile;
+
 /**
  * Mark a field computed-on-save from another field. The transform runs
  * before the row is written — `saveDraft` applies it (via
@@ -551,6 +830,9 @@ export declare interface DerivedSpec {
  */
 export declare const describeEdit: (fields: Readonly<Record<string, FieldSchema>>, before: Readonly<Record<string, unknown>>, after: Readonly<Record<string, unknown>>, words: EditWords) => EditDescription | null;
 
+/** A design system's tokens: group → token name → what it stands for (a value or a description). */
+export declare type DesignTokens = Readonly<Record<string, Readonly<Record<string, string>>>>;
+
 /** 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';
@@ -565,6 +847,36 @@ export declare interface DiffSegment {
  */
 export declare const diffWords: (before: string, after: string) => ReadonlyArray<DiffSegment>;
 
+/** Whether any block of the document holds a suggestion. */
+export declare const documentHasChanges: (doc: RichDocument) => boolean;
+
+/**
+ * The response headers that tell `provider` how to keep this answer: how long
+ * (`maxAge`, then `staleWhileRevalidate` served stale while it refetches), the
+ * `Vary` from the identity, and the purge tags in the header the provider
+ * reads (`Cache-Tag` comma-separated; Fastly's `Surrogate-Key` space-separated
+ * with its own `Surrogate-Control`). A request that is not shared-cacheable
+ * gets `private, no-store` and no tags.
+ */
+export declare const edgeHeaders: (provider: EdgeProvider, identity: CacheIdentity, lifetime: {
+    readonly maxAge: number;
+    readonly staleWhileRevalidate?: number;
+}) => Readonly<Record<string, string>>;
+
+/** A shared cache in front of the delivery API: your own (BYO) or a managed one. */
+export declare type EdgeProvider = 'cloudflare' | 'fastly' | 'generic';
+
+/**
+ * The requests that drop every cached answer carrying one of `tags`, and the
+ * answers at `urls` — none when there is nothing to purge or the target is
+ * unusable. Tags a header could not carry and addresses that are not absolute
+ * http(s) URLs are left out rather than sent.
+ */
+export declare const edgePurgeRequests: (provider: PurgeProvider, config: {
+    readonly target: string;
+    readonly token: string | null;
+}, tags: ReadonlyArray<string>, urls?: ReadonlyArray<string>) => ReadonlyArray<PurgeRequest>;
+
 /** What one change did, and a key that tells whether the next change continues it. */
 export declare interface EditDescription {
     readonly label: string;
@@ -615,11 +927,41 @@ export declare interface EditWords {
 /** The tools on for the last step of `chain`, and why each tool is as it is. */
 export declare const effectiveExposure: (input: ExposureInput) => ExposureResult;
 
+/** One inherited field of a page as the editor shows it: what it is, where it came from, and what the page may do. */
+export declare interface EffectiveInheritance extends Inherited {
+    readonly field: string;
+    readonly locked: boolean;
+    /** The mask field, when the field may be masked. */
+    readonly mask: string | null;
+    /** What it would be without the page's own value or mask — what "reset" brings back. */
+    readonly inherited: Inherited;
+}
+
+/**
+ * Every inherited field of `node` (the type's `tree.inherit`): its effective
+ * value with the document it came from and how, whether it is locked or may
+ * be masked, and what it would be after a reset. A draft not yet in the tree
+ * inherits through its parent — pass it as `node` and it is placed for the
+ * walk.
+ */
+export declare const effectiveInheritance: (inherit: Readonly<Record<string, InheritRule>>, tree: CmsTree, node: TreeNode) => ReadonlyArray<EffectiveInheritance>;
+
 export declare const EMPTY_EDIT_HISTORY: EditHistory;
 
 /** An empty document. */
 export declare const emptyRichDocument: () => RichDocument;
 
+/** The intent as a URL parameter value (`?select=…`). */
+export declare const encodeSelectionIntent: (intent: SelectionIntent) => string;
+
+/** Why a dimension is in the identity or not. */
+export declare interface ExplainLine {
+    readonly dimension: string;
+    readonly included: boolean;
+    readonly value: string | null;
+    readonly why: string;
+}
+
 export declare interface ExposureInput {
     readonly ceiling: ReadonlyArray<string>;
     readonly defaults: ReadonlyArray<string>;
@@ -648,12 +990,10 @@ export declare const EXTENSION_SLOTS: readonly ["dashboard", "sidebar", "fieldWi
 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;
-}>;
+declare const ExtensionAccessDenied_base: Schema_2.Class<ExtensionAccessDenied, Schema_2.TaggedStruct<"ExtensionAccessDenied", {
+    readonly extensionId: Schema_2.String;
+    readonly capability: Schema_2.String;
+}>, YieldableError>;
 
 /**
  * What an extension may do; everything else is refused.
@@ -669,31 +1009,31 @@ export declare type ExtensionCapability = 'content:read' | 'content:write' | `eg
 
 /** 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>;
+    readonly id: Schema_2.String;
+    readonly name: Schema_2.String;
+    readonly version: Schema_2.String;
+    readonly publisher: Schema_2.String;
+    readonly capabilities: Schema_2.$Array<Schema_2.String>;
+    readonly slots: Schema_2.$Array<Schema_2.String>;
+    readonly fields: Schema_2.optional<Schema_2.$Array<Schema_2.String>>;
+    readonly settings: Schema_2.optional<Schema_2.$Array<Schema_2.Union<readonly [Schema_2.Struct<{
+        readonly key: Schema_2.String;
+        readonly label: Schema_2.String;
+        readonly kind: Schema_2.Literal<"number">;
+        readonly default: Schema_2.Number;
+        readonly min: Schema_2.optional<Schema_2.Number>;
+        readonly max: Schema_2.optional<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;
+        readonly key: Schema_2.String;
+        readonly label: Schema_2.String;
+        readonly kind: Schema_2.Literal<"boolean">;
+        readonly default: 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>;
+        readonly key: Schema_2.String;
+        readonly label: Schema_2.String;
+        readonly kind: Schema_2.Literal<"choice">;
+        readonly default: Schema_2.String;
+        readonly options: Schema_2.$Array<Schema_2.String>;
     }>]>>>;
 }>;
 
@@ -755,6 +1095,12 @@ export declare interface FieldSchema {
     readonly pattern?: string;
     /** Closed value set for `literal` fields → `<select>` + CHECK constraint. */
     readonly literals?: ReadonlyArray<string>;
+    /** What an editor reads for each literal (a token's value, an action's purpose). */
+    readonly literalLabels?: Readonly<Record<string, string>>;
+    /** Set by `Schema.Token`: the design-token group the value names. */
+    readonly token?: string;
+    /** Set by `Schema.Action`: the value names an action the renderer binds. */
+    readonly action?: true;
     /** A `number` field that takes fractions (a `real` column); without it a number is whole. */
     readonly fraction?: boolean;
     /**
@@ -837,6 +1183,8 @@ export declare interface HtmlImportOptions {
     readonly resolveImage?: (src: string) => string | null;
     /** Block ids; defaults to a counter, so a test reads stable ids. */
     readonly newId?: () => string;
+    /** Keep `mailto:` and `tel:` links as one-off contacts (a field profile with `contactLiterals`); one that is not a usable address or number is reported. */
+    readonly contacts?: boolean;
 }
 
 export declare interface HtmlImportResult {
@@ -846,12 +1194,22 @@ export declare interface HtmlImportResult {
 
 /** Where an inherited value came from. */
 export declare interface Inherited {
-    /** The value; undefined when neither the page nor an ancestor sets it. */
+    /** The value; undefined when masked or when nothing in the tree sets it. */
     readonly value: unknown;
-    /** The document that set it: the page itself, an ancestor, or null for none. */
+    /** The document that decided it: the page itself, an ancestor, or null for none. */
     readonly from: string | null;
+    readonly how: InheritedHow;
 }
 
+/**
+ * How a page came by an inherited field:
+ *  - `own` — the page sets it;
+ *  - `ancestor` — the nearest ancestor that sets it;
+ *  - `masked` — the page or an ancestor masks it: nothing shows;
+ *  - `none` — nothing in the tree sets it (the app's site default applies).
+ */
+export declare type InheritedHow = 'own' | 'ancestor' | 'masked' | 'none';
+
 /**
  * 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
@@ -860,12 +1218,20 @@ export declare interface Inherited {
  */
 export declare const inheritedValue: (tree: CmsTree, node: TreeNode, field: string, options?: {
     readonly ancestorsOnly?: boolean;
+    readonly mask?: string;
 }) => 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;
+    /**
+     * An optional Boolean field of the same type that MASKS this one: true on a
+     * page means it shows nothing here, on purpose — not "unset" (that
+     * inherits) and not an empty value. Pages below inherit the mask until one
+     * sets its own value or mask. A locked field cannot be masked.
+     */
+    readonly mask?: string;
 }
 
 /** The minimal DOM a surface is read from (a browser element, or jsdom's). */
@@ -884,7 +1250,7 @@ export declare interface InlineDomNode {
  */
 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. */
+/** A run as the HTML a visual surface shows: `strong`, `em`, `u`, `span[data-style]`, `a[data-target]`, `a[data-contact]`, escaped text. */
 export declare const inlineHtml: (content: ReadonlyArray<RichInline>) => string;
 
 /** Inline nodes back to the editor's markup (the inverse of `parseInlineMarkup`). */
@@ -932,6 +1298,15 @@ export declare const listNumberedAt: (block: {
     readonly sublists?: ReadonlyArray<ListKind>;
 }, depth: number) => boolean;
 
+/** One stretch of time a revision was live (`to` null: still live). */
+export declare interface LiveStretch {
+    readonly revision: number;
+    readonly releaseId: string | null;
+    /** ISO timestamps. */
+    readonly from: string;
+    readonly to: string | null;
+}
+
 /** One language's published page tree. */
 export declare interface LocalizedTree {
     readonly locale: string;
@@ -960,9 +1335,61 @@ 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. */
+/** Adjacent text runs with the same marks and style become one; empty text runs go. */
 export declare const mergeInline: (content: ReadonlyArray<RichInline>) => ReadonlyArray<RichInline>;
 
+export declare interface MetricDefinition extends MetricSpec {
+    /** A digest of what the number means (not of its label or description). */
+    readonly fingerprint: string;
+}
+
+export declare type MetricDrill = 'document' | 'locale' | 'revision' | 'release';
+
+export declare type MetricFreshness = {
+    readonly kind: 'live';
+} | {
+    readonly kind: 'daily';
+} | {
+    readonly kind: 'interval';
+    readonly minutes: number;
+};
+
+export declare interface MetricSpec {
+    readonly id: string;
+    /** Raise it whenever the formula, scope, freshness, quality or drill changes. */
+    readonly version: number;
+    readonly label: string;
+    readonly description: string;
+    /** What is computed, in words a reviewer can check against the code. */
+    readonly formula: string;
+    readonly unit: MetricUnit;
+    /** What it is counted over — `site`, `environment`, `locale`, `document`, `day`… */
+    readonly scope: ReadonlyArray<string>;
+    readonly freshness: MetricFreshness;
+    /** Known limits of the number, e.g. `consent-only`, `utc-days`. */
+    readonly quality: ReadonlyArray<string>;
+    /** Where it drills down to. */
+    readonly drill: ReadonlyArray<MetricDrill>;
+}
+
+export declare type MetricUnit = 'count' | 'ratio' | 'percent' | 'seconds';
+
+/**
+ * The metrics whose meaning changed against a recorded set of
+ * `{ id, version, fingerprint }` without a new version — keep the set in a
+ * test, and this names every silent redefinition.
+ */
+export declare const metricVersionDrift: (metrics: ReadonlyArray<MetricDefinition>, recorded: ReadonlyArray<{
+    readonly id: string;
+    readonly version: number;
+    readonly fingerprint: string;
+}>) => ReadonlyArray<string>;
+
+/** The stages of a migration, in the order they pass. */
+export declare const MIGRATION_STAGES: readonly ["inventory", "mapping", "dryRun", "reconciliation", "delta", "cutover", "fallback", "uat"];
+
+export declare type MigrationStage = (typeof MIGRATION_STAGES)[number];
+
 /** `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>;
 
@@ -979,9 +1406,9 @@ 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.
+ * validator to reject. With a profile, the document records its id.
  */
-export declare const normalizeRichDocument: (value: unknown) => unknown;
+export declare const normalizeRichDocument: (value: unknown, profile?: RichTextProfile) => 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>) => {
@@ -1030,10 +1457,25 @@ export declare interface PageTemplate {
         readonly component: ComponentDefinition;
         readonly count: number;
     }>;
+    /** Other `Schema.Components` fields of the type (an aside), each with its own rules. */
+    readonly regions?: Readonly<Record<string, RegionRule>>;
+    /** The widths a component may take here: the values its `TemplatesConfig.width` prop may hold. */
+    readonly widths?: ReadonlyArray<{
+        readonly component: ComponentDefinition;
+        readonly allowed: ReadonlyArray<string>;
+    }>;
+    /** How deep components may sit inside each other's slots; 1 = no nesting. */
+    readonly maxDepth?: number;
 }
 
-/** Parse the editor's inline markup into inline nodes. Unclosed markers stay text. */
-export declare const parseInlineMarkup: (input: string) => ReadonlyArray<RichInline>;
+/** Parse the editor's inline markup into inline nodes. Unclosed markers stay text; `{name|…}` is a style only for a name in `styles`. */
+export declare const parseInlineMarkup: (input: string, styles?: ReadonlyArray<string>) => ReadonlyArray<RichInline>;
+
+/** An anchor from someone else's presence, or null when it is not one of the declared shapes. */
+export declare const parsePresenceAnchor: (value: unknown) => PresenceAnchor | null;
+
+/** An intent from a URL or a message, or null when it is not one of the declared shape. Untrusted input. */
+export declare const parseSelectionIntent: (value: unknown) => SelectionIntent | null;
 
 /** `sections.2` → `{ field: 'sections', index: 2 }`; `title` → `{ field: 'title' }`. */
 export declare const parseSourcePath: (path: string) => {
@@ -1047,6 +1489,21 @@ 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;
 
+/** One suggestion: who made it and when, the blocks it touches, and the text it puts in and takes out. */
+export declare interface PendingChange {
+    readonly id: string;
+    readonly by: string;
+    readonly at: string;
+    readonly blockIds: ReadonlyArray<string>;
+    readonly inserted: string;
+    readonly deleted: string;
+    /** Blocks it inserts or deletes whole (an image, a component, a paragraph). */
+    readonly blocks: number;
+}
+
+/** The suggestions in a document, in order of first appearance. */
+export declare const pendingChanges: (doc: RichDocument) => ReadonlyArray<PendingChange>;
+
 /** 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;
@@ -1068,6 +1525,42 @@ export declare interface PipeableField extends FieldSchema {
 /** The document's text, one line per block — for excerpts and search. */
 export declare const plainTextOf: (doc: RichDocument) => string;
 
+export declare type PresenceAnchor = {
+    readonly kind: 'view';
+    readonly view: string;
+} | {
+    readonly kind: 'field';
+    readonly field: string;
+} | {
+    readonly kind: 'component';
+    readonly field: string;
+    readonly instanceId: string;
+    readonly componentId: string;
+} | {
+    readonly kind: 'slot';
+    readonly field: string;
+    readonly instanceId: string;
+    readonly componentId: string;
+    readonly prop: string;
+} | {
+    readonly kind: 'selection';
+    readonly field: string;
+    readonly start: number;
+    readonly end: number;
+} | {
+    readonly kind: 'assetRegion';
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+};
+
+/**
+ * The anchor of a focused control in a `ContentForm`: the field, or — inside
+ * a placed component — the component, or the prop (slot) within it.
+ */
+export declare const presenceAnchorOf: (target: unknown) => PresenceAnchor | null;
+
 /** 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;
@@ -1093,24 +1586,38 @@ export declare type PreviewMessage = {
 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"]>;
-}>;
+declare const PreviewShareRejected_base: Schema_2.Class<PreviewShareRejected, Schema_2.TaggedStruct<"PreviewShareRejected", {
+    readonly reason: Schema_2.Literals<readonly ["expiryInPast", "expiryTooFar"]>;
+}>, YieldableError>;
 
 /**
  * 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.
+ * field that is empty (absent, null, or a blank string), and every rich text
+ * that still holds suggested changes. 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>;
 
+export declare type PurgeProvider = 'cloudflare' | 'fastly' | 'webhook';
+
+export declare interface PurgeRequest {
+    readonly url: string;
+    readonly method: 'POST';
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body?: string;
+}
+
 /** 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>;
 
+/** When and where a quality rule is checked; `scope` is null where no place is known (every pack then applies). */
+declare interface QualityContext {
+    readonly now: Date;
+    readonly scope: CmsScope | null;
+}
+
 /** One quality check of a type — see `ContentTypeSpec.quality`. */
 declare interface QualityRule {
     /** Stable id (letters, digits, `.`, `-`), unique in the type — exceptions name it. */
@@ -1121,10 +1628,37 @@ declare interface QualityRule {
     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;
+    /**
+     * The policy pack it belongs to (`'EU claims'`, `'German market'`) — shown
+     * beside the finding. With `sites` / `locales` a pack applies only there;
+     * absent, everywhere.
+     */
+    readonly pack?: string;
+    readonly sites?: ReadonlyArray<string>;
+    readonly locales?: ReadonlyArray<string>;
+    /** True when the values have the finding. Pure; `at` says when and where (a claim's evidence may have run out). */
+    readonly check: (values: Readonly<Record<string, unknown>>, at: QualityContext) => boolean;
 }
 
+/** One allowed query parameter. */
+export declare type QueryParam = {
+    readonly name: string;
+    readonly type: 'string';
+    readonly maxLength?: number;
+    readonly default?: string;
+} | {
+    readonly name: string;
+    readonly type: 'int';
+    readonly min?: number;
+    readonly max?: number;
+    readonly default?: number;
+} | {
+    readonly name: string;
+    readonly type: 'enum';
+    readonly values: ReadonlyArray<string>;
+    readonly default?: string;
+};
+
 /**
  * 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;
@@ -1133,13 +1667,11 @@ declare interface QualityRule {
 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;
-}>;
+declare const QuotaExceeded_base: Schema_2.Class<QuotaExceeded, Schema_2.TaggedStruct<"QuotaExceeded", {
+    readonly quota: Schema_2.String;
+    readonly limit: Schema_2.Number;
+    readonly used: Schema_2.Number;
+}>, YieldableError>;
 
 /** The editor's message, or null for anything else. */
 export declare const readEditorMessage: (event: VisualMessageEvent, session: VisualSession) => EditorMessage | null;
@@ -1192,18 +1724,25 @@ export declare const redoEdit: (history: EditHistory, current: Readonly<Record<s
 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"]>;
+declare const ReferenceUnavailable_base: Schema_2.Class<ReferenceUnavailable, Schema_2.TaggedStruct<"ReferenceUnavailable", {
+    readonly contentType: Schema_2.String;
+    readonly id: Schema_2.String;
+    readonly targets: Schema_2.$Array<Schema_2.Struct<{
+        readonly path: Schema_2.String;
+        readonly contentType: Schema_2.String;
+        readonly documentId: Schema_2.String;
+        readonly reason: Schema_2.Literals<readonly ["blocked", "expired", "notYet", "territory", "channel", "purpose"]>;
     }>>;
-}>;
+}>, YieldableError>;
+
+/** The rules of one region of a template. */
+export declare interface RegionRule {
+    /** Only these components may be placed here (all the field allows, when unset). */
+    readonly allowed?: ReadonlyArray<ComponentDefinition>;
+    readonly required?: ReadonlyArray<ComponentDefinition>;
+    /** The most components the region may hold. */
+    readonly maxItems?: number;
+}
 
 /**
  * Raised when a release is asked to change in a state that does not allow it:
@@ -1213,12 +1752,10 @@ declare const ReferenceUnavailable_base: Schema_2.TaggedErrorClass<ReferenceUnav
 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;
-}>;
+declare const ReleaseNotEditable_base: Schema_2.Class<ReleaseNotEditable, Schema_2.TaggedStruct<"ReleaseNotEditable", {
+    readonly id: Schema_2.String;
+    readonly status: Schema_2.String;
+}>, YieldableError>;
 
 /**
  * Replace the text in `[start, end)` with `text` (a paste, a typed line
@@ -1227,6 +1764,9 @@ declare const ReleaseNotEditable_base: Schema_2.TaggedErrorClass<ReleaseNotEdita
  */
 export declare const replaceText: (content: ReadonlyArray<RichInline>, start: number, end: number, text: string) => ReadonlyArray<RichInline>;
 
+/** The document with each suggestion accepted, rejected or kept, as `decide` says. */
+export declare const resolveChanges: (doc: RichDocument, decide: (change: RichChange) => ChangeDecision) => RichDocument;
+
 /**
  * Raised when a revision of a content type that requires review is published
  * without an approval of exactly that revision.
@@ -1234,13 +1774,11 @@ export declare const replaceText: (content: ReadonlyArray<RichInline>, start: nu
 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;
-}>;
+declare const ReviewRequired_base: Schema_2.Class<ReviewRequired, Schema_2.TaggedStruct<"ReviewRequired", {
+    readonly contentType: Schema_2.String;
+    readonly id: Schema_2.String;
+    readonly revisionId: Schema_2.String;
+}>, YieldableError>;
 
 /**
  * Raised by the review steps when the step does not fit the variant's review:
@@ -1249,13 +1787,18 @@ declare const ReviewRequired_base: Schema_2.TaggedErrorClass<ReviewRequired, "Re
 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", "ambiguousOrder"]>;
-}>;
+declare const ReviewStepRefused_base: Schema_2.Class<ReviewStepRefused, Schema_2.TaggedStruct<"ReviewStepRefused", {
+    readonly contentType: Schema_2.String;
+    readonly id: Schema_2.String;
+    readonly reason: Schema_2.Literals<readonly ["notInReview", "selfApproval", "ambiguousOrder"]>;
+}>, YieldableError>;
+
+declare interface ReviewWorkflow {
+    readonly id: string;
+    /** Raise it whenever the steps change: an instance keeps the version it started with. */
+    readonly version: number;
+    readonly steps: ReadonlyArray<WorkflowStep>;
+}
 
 /**
  * Raised by `publish` when the caller pinned a revision (`{ revisionId }`)
@@ -1265,28 +1808,40 @@ declare const ReviewStepRefused_base: Schema_2.TaggedErrorClass<ReviewStepRefuse
 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;
-}>;
+declare const RevisionMismatch_base: Schema_2.Class<RevisionMismatch, Schema_2.TaggedStruct<"RevisionMismatch", {
+    readonly contentType: Schema_2.String;
+    readonly id: Schema_2.String;
+    readonly expected: Schema_2.String;
+    readonly actual: Schema_2.String;
+}>, YieldableError>;
+
+/** A value attributed to the revision live when it was counted. */
+export declare interface RevisionShare extends LiveStretch {
+    readonly value: number;
+    readonly days: number;
+}
 
-/** A top-level block. `id` is stable across edits, moves and translations. */
+/** A top-level block. `id` is stable across edits, moves and translations. `style`
+ *  names a token of the profile's style group; `change` marks a block suggested
+ *  for insertion or deletion. */
 export declare type RichBlock = {
     readonly id: string;
+    readonly change?: RichChange;
     readonly type: 'paragraph';
     readonly content: ReadonlyArray<RichInline>;
+    readonly style?: string;
 } | {
     readonly id: string;
+    readonly change?: RichChange;
     readonly type: 'heading';
     readonly level: 2 | 3;
     readonly content: ReadonlyArray<RichInline>;
+    readonly style?: string;
 } | {
     readonly id: string;
+    readonly change?: RichChange;
     readonly type: 'list';
+    readonly style?: string;
     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.
@@ -1297,6 +1852,7 @@ export declare type RichBlock = {
     readonly sublists?: ReadonlyArray<ListKind>;
 } | {
     readonly id: string;
+    readonly change?: RichChange;
     readonly type: 'table';
     /** True when the first row holds the column headers. */
     readonly header: boolean;
@@ -1305,15 +1861,58 @@ export declare type RichBlock = {
 /** An image asset (by its documentId) with an optional caption. */
 | {
     readonly id: string;
+    readonly change?: RichChange;
     readonly type: 'image';
     readonly asset: string;
     readonly caption?: string;
+}
+/** A file to download — an asset (by its documentId) from the media library — and the text its link shows. */
+| {
+    readonly id: string;
+    readonly change?: RichChange;
+    readonly type: 'file';
+    readonly asset: string;
+    readonly label: string;
+}
+/** A component the profile allows, placed between blocks; `id` is its instance id. */
+| {
+    readonly id: string;
+    readonly change?: RichChange;
+    readonly type: 'component';
+    readonly componentId: string;
+    readonly props: Readonly<Record<string, unknown>>;
+    /** The definition's fingerprint when it was last saved. */
+    readonly fingerprint?: string;
+};
+
+/** A kind of block. */
+export declare type RichBlockKind = RichBlock['type'];
+
+/** A suggested change (track changes): text or a block someone proposes to insert
+ *  or delete, until it is accepted or rejected (trackChanges.ts). */
+export declare interface RichChange {
+    readonly id: string;
+    readonly kind: 'insert' | 'delete';
+    /** Who suggested it. */
+    readonly by: string;
+    /** When, as an ISO timestamp. */
+    readonly at: string;
+}
+
+/** How a contact is given: a published contact point (its documentId), or a one-off address or number. */
+export declare type RichContact = {
+    readonly target: string;
+} | {
+    readonly channel: 'email' | 'phone';
+    readonly value: string;
 };
 
 /** A rich document. */
 export declare interface RichDocument {
     readonly type: 'doc';
     readonly blocks: ReadonlyArray<RichBlock>;
+    /** The profile it was saved against (`article@2`). */
+    readonly profile?: string;
 }
 
 export declare const RichDocumentEditor: (props: RichDocumentEditorProps) => ReactNode;
@@ -1333,6 +1932,8 @@ export declare interface RichDocumentEditorProps extends WidgetProps {
      * tables keep their lines either way.
      */
     readonly surface?: 'markup' | 'visual';
+    /** Renders the props form of a component between the blocks (`ContentForm` passes its own, nested). */
+    readonly renderComponentProps?: (definition: ComponentDefinition, props: Readonly<Record<string, unknown>>, onChange: (props: Readonly<Record<string, unknown>>) => void) => ReactNode;
 }
 
 /** Translate a Contentful rich-text document, and say what could not be translated. */
@@ -1350,6 +1951,15 @@ export declare type RichDocumentPicker = (props: {
     readonly type: string;
     readonly value: string;
     readonly onChange: (documentId: string) => void;
+    /** Where the choice goes, for a picker that hands off to another tool (a selection intent): the field and, inside a rich text, the block. */
+    readonly target?: {
+        readonly field: string;
+        readonly blockId?: string;
+    };
+    /** What the choice is for — an image block's image, a download block's file, a link's target, a contact — when two pickers share a `type`. */
+    readonly role?: 'image' | 'file' | 'link' | 'contact';
+    /** The id of the element that names the choice (a link's "Link to"): a control the picker renders is labelled by it (`aria-labelledby`). */
+    readonly labelledBy?: string;
 }) => ReactNode;
 
 /** One problem with a rich document, at a path below the field. */
@@ -1359,7 +1969,7 @@ export declare interface RichDocumentProblem {
     readonly message: string;
 }
 
-/** Everything wrong with `value` as a rich document under `options`. */
+/** Everything wrong with `value` as a rich document under `options` (component props are checked by the caller). */
 export declare const richDocumentProblems: (path: string, value: unknown, options: RichTextOptions) => ReadonlyArray<RichDocumentProblem>;
 
 /** A document reference found in a rich document. */
@@ -1373,7 +1983,7 @@ export declare interface RichDocumentReference {
 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 const RichDocumentView: ({ document, hrefOf, renderImage, contactHrefOf, renderComponent, fileHrefOf }: RichDocumentViewProps) => ReactNode;
 
 export declare interface RichDocumentViewProps {
     /** A stored `Schema.RichText()` value (a plain string renders as paragraphs). */
@@ -1385,19 +1995,37 @@ export declare interface RichDocumentViewProps {
         readonly asset: string;
         readonly caption?: string;
     }) => ReactNode;
-}
-
-/** A run of text inside a block. */
-export declare type RichInline = {
+    /** The `mailto:` / `tel:` address of a published contact point, or undefined when it is not live. */
+    readonly contactHrefOf?: (documentId: string) => string | undefined;
+    /** Render a component placed between the blocks; without it, components are left out. */
+    readonly renderComponent?: (block: ComponentBlock) => ReactNode;
+    /** The address a download block's file is fetched from, or undefined when it is not live — then the download is left out, never a dead link. */
+    readonly fileHrefOf?: (asset: string) => string | undefined;
+}
+
+/** A run of text inside a block. `change` marks it as suggested. */
+export declare type RichInline = 
+/** `style` names a token of the profile's style group (`lead`, `note`). */
+    {
     readonly type: 'text';
     readonly text: string;
     readonly marks?: ReadonlyArray<RichMark>;
+    readonly style?: string;
+    readonly change?: RichChange;
 }
 /** A link to a document (by its documentId) — the site resolves its address. */
 | {
     readonly type: 'link';
     readonly target: string;
     readonly text: string;
+    readonly change?: RichChange;
+}
+/** An e-mail address or a phone number — the site makes it a `mailto:` / `tel:` link. */
+| {
+    readonly type: 'contact';
+    readonly text: string;
+    readonly contact: RichContact;
+    readonly change?: RichChange;
 };
 
 /** An inline mark. */
@@ -1405,12 +2033,39 @@ 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.
+ * an image block references (an asset type), `files` the type a download
+ * 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 images?: string;
+    /** The asset type a download block references; unset → no downloads. */
+    readonly files?: string;
     readonly links?: string;
+    /** What this field allows beyond that; without one, every built-in block and mark, no styles, components or contacts. */
+    readonly profile?: RichTextProfile;
+}
+
+/** What a rich-text field allows (`defineRichTextProfile`). Versioned: a change bumps `version`. */
+export declare interface RichTextProfile {
+    readonly name: string;
+    readonly version: number;
+    /** `<name>@<version>` — what a saved document records. */
+    readonly id: string;
+    readonly blocks: ReadonlyArray<RichBlockKind>;
+    readonly headings: ReadonlyArray<2 | 3>;
+    readonly marks: ReadonlyArray<RichMark>;
+    /** Named styles of paragraphs, headings, lists and runs of text: one design-token group, name → meaning. */
+    readonly styles?: {
+        readonly group: string;
+        readonly tokens: Readonly<Record<string, string>>;
+    };
+    /** The components that may sit between the blocks. */
+    readonly components: ReadonlyArray<ComponentDefinition>;
+    /** The content type of the published contact points (e-mail, phone) a text may name. */
+    readonly contactPoints?: string;
+    /** Whether a text may hold a one-off e-mail address or phone number (checked on save). */
+    readonly contactLiterals: boolean;
 }
 
 export declare const RichTextSurface: (props: RichTextSurfaceProps) => ReactNode;
@@ -1454,6 +2109,20 @@ export declare const Schema: {
     readonly unique: () => FieldRefinement;
     /** Closed value set → `<select>` widget + a CHECK constraint. */
     readonly Literal: (values_0: string, ...values: string[]) => PipeableField;
+    /**
+     * A design token of one group (`tone`, `space`) from the set the design
+     * system declares with `defineDesignTokens`: the editor picks a NAME, never
+     * a colour or a size, and the renderer maps the name to its style. Stored
+     * and checked like a literal.
+     */
+    readonly Token: (tokens: DesignTokens, group: string) => PipeableField;
+    /**
+     * An action a component performs, chosen from the ones its renderer
+     * implements (`{ follow: 'Go to the target page', share: 'Share this page' }`):
+     * the editor picks what happens, the developer owns how. Stored and checked
+     * like a literal; the labels are what the editor reads.
+     */
+    readonly Action: (actions: Readonly<Record<string, string>>) => PipeableField;
     /**
      * Rich text, stored as a `RichDocument` (see richDocument.ts): blocks with
      * stable ids — paragraph, heading, list, table, image — and inline text
@@ -1491,12 +2160,61 @@ declare interface SearchConfig {
     readonly title: string;
 }
 
+/** The answer of an intent: which resource was chosen. */
+export declare interface SelectionAnswer {
+    readonly intentId: string;
+    readonly documentId: string;
+    /** What the chosen resource is called — the link text when nothing was selected. */
+    readonly title?: string;
+}
+
+export declare interface SelectionIntent {
+    readonly id: string;
+    /** The content type to pick from (`asset`, `page`). */
+    readonly pick: string;
+    /** What kind of it is wanted, when the type holds several (`image`, `file`); the tool shows only those. */
+    readonly kind?: string;
+    readonly target: SelectionTarget;
+    /** The app-relative address to go back to. */
+    readonly returnTo: string;
+    /** What the picking tool shows about the target (`Planting guide — Text, image 3`). */
+    readonly label?: string;
+}
+
+/** Where a chosen resource goes. */
+export declare interface SelectionTarget {
+    /** The type being edited; the document and the revision the intent was made on — or, before the draft is saved, the open form (`formId`). */
+    readonly type: string;
+    readonly documentId?: string;
+    readonly revisionId?: string;
+    readonly formId?: string;
+    readonly locale?: string;
+    /** The field; with `blockId`, a block of that rich text (an image block's asset, or a link over `selection`). */
+    readonly field: string;
+    readonly blockId?: string;
+    /** With `prop`: a placed component of a components field, by its instance id, and the prop that takes the choice. */
+    readonly instanceId?: string;
+    readonly prop?: string;
+    /** For a link: the text it is made over, by character offset in the block's text. */
+    readonly selection?: {
+        readonly start: number;
+        readonly end: number;
+    };
+}
+
 /** 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>>;
 
+/**
+ * Whether an origin response may be stored by a shared cache: eligibility is
+ * checked again after the origin answered — a `Set-Cookie`, `private` or
+ * `no-store` keeps it out whatever the request looked like.
+ */
+export declare const sharedCacheable: (headers: Readonly<Record<string, string | undefined>>) => boolean;
+
 export declare interface SitemapUrl extends PageAlternate {
     readonly documentId: string;
     /** ISO date of the variant's last change, when known. */
@@ -1533,6 +2251,16 @@ export declare const sourceAttributes: (path: string) => {
 /** The field path behind a clicked element of the preview, or null. */
 export declare const sourcePathOf: (target: unknown) => string | null;
 
+/** A placed component saved against an earlier definition of it, with no migration to upgrade it. */
+export declare interface StaleComponent {
+    readonly path: string;
+    readonly componentId: string;
+    readonly fingerprint: string | null;
+}
+
+/** The instances in `values` (nested ones included) that a save would not upgrade — their definition changed and names no migration from them. */
+export declare const staleComponents: (type: Pick<ContentType, "fields">, values: Readonly<Record<string, unknown>>) => ReadonlyArray<StaleComponent>;
+
 /** A type's taxonomy — see `ContentTypeSpec.taxonomy`. */
 export declare interface TaxonomyConfig {
     /** A declared `Schema.Array(Schema.String)` field. */
@@ -1554,6 +2282,8 @@ export declare interface TemplatesConfig {
     readonly field: string;
     /** The `Schema.Components` field the rules apply to. */
     readonly components: string;
+    /** The component prop that holds a placement's width (`widths`); default `width`. */
+    readonly width?: string;
     readonly list: ReadonlyArray<PageTemplate>;
 }
 
@@ -1567,6 +2297,9 @@ export declare const templateValues: (type: Typed, templateId: string) => Record
 /** 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>;
 
+/** The current selection inside a text surface, as character offsets into its text — what a selection intent's `selection` is made of; null when it is elsewhere. */
+export declare const textSelectionIn: (root: HTMLElement) => [number, number] | null;
+
 /**
  * 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
@@ -1584,6 +2317,38 @@ export declare interface ToolExposure {
 /** An XLIFF 2.1 core document for one file. */
 export declare const toXliff: (exchange: XliffExchange) => string;
 
+/** `edited` (a copy of `base` someone changed) as suggestions inside `base`. */
+export declare const trackChanges: (base: RichDocument, edited: RichDocument, author: ChangeAuthor) => TrackedChanges;
+
+/** The document with the edit suggested, and the blocks it could not suggest over (they hold others' suggestions). */
+export declare interface TrackedChanges {
+    readonly document: RichDocument;
+    readonly conflicts: ReadonlyArray<string>;
+}
+
+/** One run with the edit from `base` to `edited` suggested: the changed middle as a deletion and an insertion. */
+export declare const trackInline: (base: ReadonlyArray<RichInline>, edited: ReadonlyArray<RichInline>, author: ChangeAuthor) => ReadonlyArray<RichInline>;
+
+/**
+ * What an exchange does not carry, so the export can say so instead of
+ * losing it silently:
+ *
+ * - `suggestedChange`: a block holds suggested changes (track changes). Its
+ *   text goes out as written, insertions and deletions alike, and a
+ *   translation coming back has no suggestion marks — decide them first.
+ * - `unknownComponent`: a component whose definition the field no longer
+ *   declares; its text is not exported and stays as it is.
+ */
+export declare interface TranslationLoss {
+    /** Where: `body/<blockId>`, `sections/<instanceId>`, or deeper inside a component. */
+    readonly id: string;
+    /** Suggested changes flattened into the text, or a component's text left out. */
+    readonly kind: 'suggestedChange' | 'unknownComponent';
+}
+
+/** What exporting these values as translation units leaves out or flattens, in field order. */
+export declare const translationLosses: (fields: Readonly<Record<string, FieldSchema>>, values: Readonly<Record<string, unknown>>, prefix?: string) => ReadonlyArray<TranslationLoss>;
+
 export declare interface TranslationUnit {
     /** Where the text lives: `title`, `body/<blockId>`, `body/<blockId>/<item>`,
      *  `body/<blockId>/<row>.<cell>`, `body/<blockId>/caption`,
@@ -1725,8 +2490,23 @@ export declare interface WidgetProps {
     readonly field: FieldSchema;
     readonly value: unknown;
     readonly onChange: (value: unknown) => void;
+    /**
+     * Where the value lives: the field, and for a prop of a placed component
+     * its instance and prop — what a picker hands to a selection intent.
+     */
+    readonly target?: WidgetTarget;
 }
 
+/** Where a widget's value lives (a `SelectionTarget`'s `field`, `instanceId`, `prop`). */
+declare interface WidgetTarget {
+    readonly field: string;
+    readonly instanceId?: string;
+    readonly prop?: string;
+}
+
+/** A block with its text replaced by `text` in its markup (the inverse of `blockMarkup`); `styles` are the names `{name|…}` may use. */
+export declare const withBlockMarkup: (block: RichBlock, text: string, styles?: ReadonlyArray<string>) => RichBlock;
+
 /** A component withheld for want of consent: which purpose would release it. */
 export declare interface WithheldInstance {
     readonly instanceId: string;
@@ -1735,6 +2515,22 @@ export declare interface WithheldInstance {
     readonly props: Readonly<Record<string, never>>;
 }
 
+declare interface WorkflowStep {
+    /** camelCase, unique within the workflow. */
+    readonly id: string;
+    readonly label: string;
+    /** The scope a person needs to decide this step (a delegate decides without it). */
+    readonly approverScope: string;
+    /** Steps that must be approved before this one opens. */
+    readonly after?: ReadonlyArray<string>;
+    /** The step applies only when this holds for the revision's values. */
+    readonly when?: (values: Readonly<Record<string, unknown>>) => boolean;
+    /** Hours the step may stay open once it is open; later it is overdue. */
+    readonly slaHours?: number;
+    /** Approving needs evidence: a link or a note saying what was checked. */
+    readonly evidence?: boolean;
+}
+
 export declare interface XliffExchange {
     readonly srcLang: string;
     readonly trgLang: string;