@voltro/cms 0.81.0 → 0.83.0

package/dist/index.d.ts

@@ -1,10 +1,171 @@
 import { DataStore } from '@voltro/database';
-import { Effect } from 'effect';
+import { Effect } from 'effect/Effect';
+import { Effect as Effect_2 } from 'effect';
 import { ReactNode } from 'react';
 import { Row } from '@voltro/database';
 import { Schema as Schema_2 } from 'effect';
 import { TableLike } from '@voltro/database';
 
+/** Effect form of {@link addRedirect}. */
+export declare const addRedirect: (...args: Parameters<typeof addRedirect_2>) => Effect<void, never, never>;
+
+/**
+ * Point a former address at a document — an address from before an import, a
+ * vanity path. Replaces an earlier redirect from the same path. A live page at
+ * `fromPath` still wins over it (`cms.route` tries the tree first). In the
+ * caller's transaction.
+ */
+declare const addRedirect_2: (tx: DataStore, type: ContentType, scope: CmsScope, fromPath: string, documentId: string, tenantId?: unknown) => Promise<void>;
+
+/** Effect form of {@link addToRelease}. */
+export declare const addToRelease: (...args: Parameters<typeof addToRelease_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound | ReleaseNotEditable, never>;
+
+/**
+ * Put one variant into a draft release: `publish` pins a revision (default:
+ * the variant's current revision), `unpublish` takes it down. A variant is in
+ * a release at most once — adding it again replaces its entry. Throws
+ * `ReleaseNotEditable` unless the release is still a draft, and
+ * `ContentNotFound` when the variant is not the caller's.
+ */
+declare const addToRelease_2: (store: DataStore, releaseId: string, item: {
+    readonly type: ContentType;
+    readonly id: string;
+    readonly locale: string;
+    readonly action?: "publish" | "unpublish";
+    readonly revisionId?: string;
+}) => Promise<Row>;
+
+/** Effect form of {@link adoptWinner}. */
+export declare const adoptWinner: (...args: Parameters<typeof adoptWinner_2>) => Effect<AdoptWinnerResult, ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch | ReleaseNotEditable, never>;
+
+/**
+ * Take version B live the way every change goes live: stop the experiment
+ * (if it still runs), save B's text over the page's draft as a new draft
+ * revision, and pin that revision in a new draft release named after the
+ * experiment. Nothing is published here — the release is, by whoever may,
+ * through the review gate, a schedule, or by hand; and it rolls back like any
+ * other. Runs in the caller's transaction.
+ */
+declare const adoptWinner_2: (tx: DataStore, type: ContentType, experimentId: string, now?: Date) => Promise<AdoptWinnerResult>;
+
+export declare type AdoptWinnerResult = {
+    readonly ok: true;
+    readonly releaseId: string;
+    readonly revisionId: string;
+} | {
+    readonly ok: false;
+    readonly reason: 'notFound' | 'alreadyAdopted' | 'noDraft';
+};
+
+/** Effect form of {@link advanceSeries}. */
+export declare const advanceSeries: (...args: Parameters<typeof advanceSeries_2>) => Effect<readonly string[], ContentValidationFailed | ContentNotFound, never>;
+
+/**
+ * Arm the next occurrence of every running series of `type` whose draft has
+ * nothing pending any more (the armed occurrence went live and came down), and
+ * end the series after its last. Returns the draft ids that were armed. Run it
+ * after `publishDue` and `unpublishDue` in the same schedule; a store outside a
+ * transaction sweeps every tenant.
+ */
+declare const advanceSeries_2: (store: DataStore, type: ContentType, now?: Date) => Promise<ReadonlyArray<string>>;
+
+export declare const AI_OUTCOMES: readonly ["suggested", "failed", "applied", "discarded"];
+
+/** Effect form of {@link aiBudgetLeft}. */
+export declare const aiBudgetLeft: (...args: Parameters<typeof aiBudgetLeft_2>) => Effect<number | null, never, never>;
+
+/** What is left of the workspace's monthly budget: a number of tokens, or null (no limit). */
+declare const aiBudgetLeft_2: (store: DataStore, tenantId: string, now?: Date) => Promise<number | null>;
+
+export declare interface AiOperation {
+    readonly id: string;
+    readonly operation: string;
+    readonly version: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly field: string | null;
+    readonly revisionId: string | null;
+    readonly outcome: AiOutcome;
+    readonly inputTokens: number | null;
+    readonly outputTokens: number | null;
+    readonly at: number;
+}
+
+export declare interface AiOperationInput {
+    readonly operation: string;
+    readonly version: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly contentType: string;
+    readonly variantId: string;
+    readonly revisionId?: string | null;
+    readonly field?: string | null;
+    readonly prompt: string;
+    readonly usage?: {
+        readonly inputTokens?: number;
+        readonly outputTokens?: number;
+    };
+    readonly outcome: 'suggested' | 'failed';
+    readonly error?: string | null;
+    readonly actor?: string | null;
+}
+
+/** Effect form of {@link aiOperationsFor}. */
+export declare const aiOperationsFor: (...args: Parameters<typeof aiOperationsFor_2>) => Effect<readonly AiOperation[], never, never>;
+
+/** A variant's AI operations, newest first. */
+declare const aiOperationsFor_2: (store: DataStore, contentType: string, variantId: string) => Promise<ReadonlyArray<AiOperation>>;
+
+export declare type AiOutcome = (typeof AI_OUTCOMES)[number];
+
+export declare interface AiSettings {
+    /** Null: the deployment's provider and model (only a budget is set). */
+    readonly provider: string | null;
+    readonly model: string | null;
+    /** The workspace's own key — for the server's call only. */
+    readonly apiKey: string | null;
+    /** Tokens per calendar month (UTC), or null: no limit. */
+    readonly monthlyTokens: number | null;
+}
+
+/** Effect form of {@link aiSettings}. */
+export declare const aiSettings: (...args: Parameters<typeof aiSettings_2>) => Effect<AiSettings | null, never, never>;
+
+/** How the workspace reaches a model, or null: the deployment's default. */
+declare const aiSettings_2: (store: DataStore, tenantId: string) => Promise<AiSettings | null>;
+
+/** Effect form of {@link aiTokensUsed}. */
+export declare const aiTokensUsed: (...args: Parameters<typeof aiTokensUsed_2>) => Effect<number, never, never>;
+
+/** Tokens (in + out) the workspace's AI calls used since `since` (default: this month). */
+declare const aiTokensUsed_2: (store: DataStore, tenantId: string, since?: Date) => Promise<number>;
+
+/** A document's address in every language it has its own variant in. */
+export declare const alternatesOf: (trees: ReadonlyArray<LocalizedTree>, documentId: string) => ReadonlyArray<PageAlternate>;
+
+/** Effect form of {@link applyBlueprint}. */
+export declare const applyBlueprint: (...args: Parameters<typeof applyBlueprint_2>) => Effect<BlueprintPlan, ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch | ReviewRequired | ReferenceUnavailable | BlueprintInvalid, never>;
+
+/**
+ * Provision `blueprint` into `target`: every step the plan calls `create` is
+ * saved (and published unless the entry says otherwise or its type needs a
+ * review); present documents stay exactly as they are. Running it again
+ * creates nothing. Runs in the caller's transaction — all of it or none;
+ * a save's `ContentValidationFailed` or a publish's `ReferenceUnavailable`
+ * (a referenced document that is not live) aborts it.
+ */
+declare const applyBlueprint_2: (tx: DataStore, types: ReadonlyArray<ContentType>, blueprint: Blueprint, target: BlueprintTarget) => Promise<BlueprintPlan>;
+
+/** Effect form of {@link applyBlueprintTeam}. */
+export declare const applyBlueprintTeam: (...args: Parameters<typeof applyBlueprintTeam_2>) => Effect<TeamPlan, never, never>;
+
+/**
+ * Provision the team, in the caller's transaction: a default role only where
+ * the workspace has none, an invitation only for an address not invited yet —
+ * running it again changes nothing, and nothing an admin changed is undone.
+ */
+declare const applyBlueprintTeam_2: (tx: DataStore, tenantId: string, team: BlueprintTeam) => Promise<TeamPlan>;
+
 /**
  * Compute every `derivedFrom` field from its source value. Returns a NEW
  * row — the input is not mutated. A caller-provided value for a derived
@@ -13,24 +174,359 @@ import { TableLike } from '@voltro/database';
  * 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>;
+
+/** The values a reader of `variant` sees: version B's text over the published values. */
+export declare const applyVariant: (values: Readonly<Record<string, unknown>>, experiment: Pick<Experiment, "overrides">, variant: Variant) => Readonly<Record<string, unknown>>;
+
+/** Effect form of {@link approveReview}. */
+export declare const approveReview: (...args: Parameters<typeof approveReview_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound | RevisionMismatch | ReviewStepRefused, never>;
 
 /**
- * Archive a content row: set `status: 'archived'` on the draft AND the
- * published copy (whichever exist). Archived rows stay in their tables
- * but disappear from the read surface (`ctx.cms` excludes `archived`).
- * Atomic per row. Throws `ContentNotFound` when the id exists in neither
- * table within the caller's scope.
+ * Approve the revision in review. Throws `RevisionMismatch` when the draft
+ * moved on since the reviewer looked, `ReviewStepRefused` when nothing is in
+ * review for that revision, the approver asked for it themselves, or existing
+ * unsequenced history has ambiguous timestamps. Use the caller's transaction.
  */
-export declare const archive: (store: DataStore, type: ContentType, id: string) => Promise<void>;
+declare const approveReview_2: (store: DataStore, type: ContentType, variantId: string, scope: CmsScope, options: DecideOptions) => Promise<Row>;
 
 /** Effect-native `archive` (see {@link saveDraftEffect}). */
-export declare const archiveEffect: (store: DataStore, type: ContentType, id: string) => Effect.Effect<void, ContentNotFound>;
+export declare const archive: (store: DataStore, type: ContentType, id: string, scope: CmsScope) => Effect_2.Effect<void, ContentNotFound>;
+
+/** Effect form of {@link assertApproved}. */
+export declare const assertApproved: (...args: Parameters<typeof assertApproved_2>) => Effect<void, ReviewRequired, never>;
+
+/**
+ * The publish gate: for a type that requires review, `revisionId` must carry
+ * an approval. Called by `publishRevision` — so single publishes, releases,
+ * rollbacks and scheduled publishing all pass the same gate.
+ */
+declare const assertApproved_2: (store: DataStore, type: ContentType, variantId: string, scope: CmsScope, revisionId: string) => Promise<void>;
+
+/** Effect form of {@link assertReferencesAvailable}. */
+export declare const assertReferencesAvailable: (...args: Parameters<typeof assertReferencesAvailable_2>) => Effect<void, ReferenceUnavailable, never>;
+
+/**
+ * The publish gate: a revision whose values reference an unavailable
+ * document is refused with `ReferenceUnavailable`, naming each one.
+ */
+declare const assertReferencesAvailable_2: (tx: DataStore, type: ContentType, variantId: string, values: Readonly<Record<string, unknown>>, scope: CmsScope, now?: Date) => Promise<void>;
+
+/** The version a reader is shown: the same reader, the same version, every time. */
+export declare const assignVariant: (experimentId: string, readerId: string, share: number) => Variant;
+
+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`. */
+export 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;
+}
+
+/** Effect form of {@link bindExtensionSecret}. */
+export declare const bindExtensionSecret: (...args: Parameters<typeof bindExtensionSecret_2>) => Effect<SecretBinding, never, never>;
+
+/**
+ * Set (or, with `value: null`, remove) the secret `name` for an extension.
+ * Only a secret its running or waiting version asks for (`secret:<name>`).
+ */
+declare const bindExtensionSecret_2: (tx: DataStore, extensionId: string, name: string, value: string | null) => Promise<SecretBinding>;
+
+export declare type BlockReason = 'notFound' | 'reviewRequired' | 'incomplete' | 'referenceUnavailable' | 'notPublished' | 'unknownType' | 'invalid' | 'revisionMoved';
+
+export declare interface Blueprint {
+    readonly id: string;
+    readonly displayName: string;
+    /** The language `values` are written in. */
+    readonly locale: string;
+    readonly entries: ReadonlyArray<BlueprintEntry>;
+    /** The team the workspace starts with: the default role and people invited with a role (team.ts). */
+    readonly team?: BlueprintTeam;
+}
+
+/** One document a blueprint provisions. */
+export declare interface BlueprintEntry {
+    /** Unique within the blueprint; another entry points at this one with `blueprintRef(key)`. */
+    readonly key: string;
+    /** The content type's name. */
+    readonly type: string;
+    /**
+     * The field that says the workspace already has this document (e.g. `slug`),
+     * compared after derivations. Omitted: any document of the type counts — for
+     * a type a workspace holds one of, like its site document.
+     */
+    readonly match?: string;
+    /** A template of the type the document is built from; `values` go over it. */
+    readonly template?: string;
+    /** Field values in the blueprint's language. `blueprintRef(key)` anywhere stands for that entry's document id. */
+    readonly values: Readonly<Record<string, unknown>>;
+    /** The same document in further languages: the values that differ from `values`. */
+    readonly translations?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    /** Publish what is created (default true). A type that needs review stays a draft. */
+    readonly publish?: boolean;
+}
+
+/** The declaration or its target does not fit: an unknown key, type, field, template or a cycle. */
+export declare class BlueprintInvalid extends Error {
+    readonly reason: string;
+    readonly _tag = "BlueprintInvalid";
+    constructor(reason: string);
+}
+
+export declare interface BlueprintPlan {
+    readonly blueprint: string;
+    readonly steps: ReadonlyArray<BlueprintStep>;
+    /** New documents a create would start (translations of them not counted). */
+    readonly documents: number;
+}
+
+/** A value that stands for another entry's document id. */
+export declare const blueprintRef: (key: string) => {
+    readonly $entry: string;
+};
+
+/** One language variant of one entry. */
+export declare interface BlueprintStep {
+    readonly key: string;
+    readonly type: string;
+    readonly locale: string;
+    /** What the step is about: the document's title (the one there already, for a present step), else its `match` value, else the key. */
+    readonly label: string;
+    readonly action: 'create' | 'present';
+    /** The document: the one there already, or (after applying) the one created. Null for a planned create. */
+    readonly documentId: string | null;
+    /** Its variant in `locale`, likewise. */
+    readonly variantId: string | null;
+    /** For a create: `live` is published, `draft` is not meant to be, `review` needs an approval first. */
+    readonly outcome: 'live' | 'draft' | 'review' | null;
+}
+
+/** Where a blueprint is provisioned: a site and environment of the caller's tenant. */
+export declare interface BlueprintTarget {
+    readonly site: string;
+    readonly environment: string;
+}
+
+/** A blueprint's team: the default role and the people invited with a role. */
+export declare interface BlueprintTeam {
+    readonly defaultRole?: string;
+    readonly members?: ReadonlyArray<{
+        readonly email: string;
+        readonly role: string;
+    }>;
+    /** Content types (with `review.required: 'workspace'`) whose publishing needs a review in the workspace. */
+    readonly reviewRequired?: ReadonlyArray<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;
+
+/** What to do to every item. */
+export declare type BulkAction = {
+    readonly kind: 'publish';
+} | {
+    readonly kind: 'unpublish';
+} | {
+    readonly kind: 'setOwner';
+    readonly owner: string | null;
+}
+/** Save a new draft revision of each item with one field changed (null
+*  clears it) — a field a person edits: not derived, not rich text or components. */
+| {
+    readonly kind: 'setField';
+    readonly field: string;
+    readonly value: unknown;
+};
+
+/** One locale variant (a draft id) of a document. */
+export declare interface BulkItem {
+    readonly type: string;
+    readonly id: string;
+    readonly locale: string;
+}
+
+export declare interface BulkResult extends BulkItem {
+    readonly title: string;
+    readonly outcome: 'done' | 'unchanged' | 'failed';
+    readonly reason: BlockReason | 'failed' | null;
+    readonly detail: ReadonlyArray<string>;
+}
+
+/** Effect form of {@link cancelSeries}. */
+export declare const cancelSeries: (...args: Parameters<typeof cancelSeries_2>) => Effect<boolean, ContentValidationFailed | ContentNotFound, never>;
+
+/** End a draft's series and clear what it armed. True when there was one. In the caller's transaction. */
+declare const cancelSeries_2: (tx: DataStore, type: ContentType, draftId: string) => Promise<boolean>;
+
+/** 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>;
+
+export declare interface ChangeEntry {
+    readonly id: string;
+    /** Epoch milliseconds. */
+    readonly at: number;
+    readonly locale: string;
+    readonly contentType: string;
+    readonly documentId: string;
+    readonly variantId: string;
+    readonly action: 'published' | 'unpublished';
+    readonly revision: number | null;
+    readonly releaseId: string | null;
+}
+
+export declare interface ChangeOrigin {
+    /** The release applying this change. */
+    readonly releaseId?: 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 const CMS_AI_OPERATIONS_TABLE = "cms_ai_operations";
+
+export declare const CMS_AI_SETTINGS_TABLE = "cms_ai_settings";
+
+/** The system table holding the availability of published documents. */
+export declare const CMS_AVAILABILITY_TABLE = "cms_availability";
+
+export declare const CMS_CHANGES_TABLE = "cms_changes";
+
+export declare const CMS_DRAFT_TEXTS_TABLE = "cms_draft_texts";
+
+export declare const CMS_EXPERIMENT_EVENTS_TABLE = "cms_experiment_events";
+
+export declare const CMS_EXPERIMENTS_TABLE = "cms_experiments";
+
+export declare const CMS_EXTENSION_DATA_TABLE = "cms_extension_data";
+
+export declare const CMS_EXTENSION_SECRETS_TABLE = "cms_extension_secrets";
+
+export declare const CMS_EXTENSIONS_TABLE = "cms_extensions";
+
+export declare const CMS_GLOSSARY_TABLE = "cms_glossary";
+
+export declare const CMS_PATHS_TABLE = "cms_paths";
+
+/** The system table holding preview shares. */
+export declare const CMS_PREVIEW_SHARES_TABLE = "cms_preview_shares";
+
+export declare const CMS_PUBLISH_SERIES_TABLE = "cms_publish_series";
+
+export declare const CMS_QUALITY_EXCEPTIONS_TABLE = "cms_quality_exceptions";
+
+export declare const CMS_REDIRECTS_TABLE = "cms_redirects";
+
+/** The system table holding the reference edges of every published variant. */
+export declare const CMS_REFERENCES_TABLE = "cms_references";
+
+export declare const CMS_RELEASE_ITEMS_TABLE = "cms_release_items";
+
+export declare const CMS_RELEASES_TABLE = "cms_releases";
+
+/** The system table holding every review step. */
+export declare const CMS_REVIEWS_TABLE = "cms_reviews";
+
+/** The system table holding every saved revision of every content type. */
+export declare const CMS_REVISIONS_TABLE = "cms_revisions";
+
+/** The scope columns, in the order they lead every scoped key. */
+export declare const CMS_SCOPE_COLUMNS: readonly ["site", "environment", "locale"];
+
+export declare const CMS_SEARCH_TABLE = "cms_search";
+
+export declare const CMS_STEWARDSHIP_TABLE = "cms_stewardship";
+
+export declare const CMS_TEAM_INVITATIONS_TABLE = "cms_team_invitations";
+
+export declare const CMS_TEAM_TABLE = "cms_team";
+
+/** One AI call on a document, and what became of it. */
+export declare const cmsAiOperationsTable: TableLike;
+
+/** One row per workspace: how it reaches a model. */
+export declare const cmsAiSettingsTable: TableLike;
 
 /** The CMS read surface attached to `ctx.cms` (and the standalone client). */
 export declare interface CmsApi {
     /** Open a query over a content type's PUBLISHED rows (archived excluded). */
     contentType(name: string): ContentQuery;
+    /**
+     * Find one published entry in the surface's locale, else along `fallback`
+     * (ADR-CMS-002). A key found in a fallback locale whose document DOES have a
+     * variant in the requested locale resolves to that variant — so the result
+     * may carry a different key value (its canonical address). Otherwise the
+     * fallback variant is returned with `fallback: true`. Null when nothing
+     * matches in any locale.
+     */
+    resolve(type: string, options: ResolveOptions): Promise<ResolvedEntry | null>;
+    /**
+     * The type's published documents as a tree (the type must declare
+     * `tree`), one variant per document: the surface's locale, else the first
+     * `fallback` locale that has one. Reads every published row of the type in
+     * those locales.
+     */
+    tree(type: string, options?: TreeOptions): Promise<CmsTree>;
+    /**
+     * Find the document at `path` (segments joined with `/`) in the tree. A
+     * path that only exists in a fallback locale's tree answers with the
+     * requested locale's node of the same document. A path no live page has
+     * but a published page had before it moved answers with that page at its
+     * current address (ADR-CMS-023). Null when none of these match.
+     */
+    route(type: string, path: string, options?: TreeOptions): Promise<RouteMatch | null>;
+    /**
+     * Whether `path` is GONE: no live page answers it ({@link CmsApi.route}
+     * finds nothing), but a published page had it — its address before it was
+     * taken down or archived, or a former address pointing at such a page — in
+     * the surface's locale or along `fallback`. A site answers it with 410
+     * rather than 404.
+     */
+    gone(type: string, path: string, options?: TreeOptions): Promise<boolean>;
+    /**
+     * Where a document is used by published content in the surface's site and
+     * environment, across locales (the `cms_references` edges publishing
+     * writes). A draft that references it is not a use until it is published.
+     */
+    usedBy(type: string, documentId: string): Promise<ReadonlyArray<ReferenceUse>>;
     /**
      * Resolve a single row honouring a preview token. With a valid token
      * for `{type, id}`, reads the DRAFT row; otherwise reads the published
@@ -40,13 +536,92 @@ export declare interface CmsApi {
 }
 
 /**
- * Build the `ctx.cms` surface over a request-scoped store. Attach the
- * result to your `AppContext` slot (or read it via `useCms(ctx)`).
+ * One row per published document of a type that declares `availability`.
+ * Register it in the app's `databaseHandle` when any type declares it.
  */
-export declare const cmsContext: (store: DataStore, types: ReadonlyArray<ContentType>, options?: {
-    secret?: string;
+export declare const cmsAvailabilityTable: TableLike;
+
+export declare const cmsChangesTable: TableLike;
+
+/**
+ * Build the `ctx.cms` surface over a request-scoped store, confined to one
+ * `scope` (site, environment, locale). Attach the result to your
+ * `AppContext` slot (or read it via `useCms(ctx)`).
+ */
+export declare const cmsContext: (store: DataStore, types: ReadonlyArray<ContentType>, options: {
+    readonly scope: CmsScope;
+    readonly secret?: string;
 }) => CmsApi;
 
+/** One text field of one draft (a document in one language), as a CRDT text. */
+export declare const cmsDraftTextsTable: TableLike;
+
+export declare const cmsExperimentEventsTable: TableLike;
+
+export declare const cmsExperimentsTable: TableLike;
+
+/** An extension's own data, by key, in its namespace. */
+export declare const cmsExtensionDataTable: TableLike;
+
+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>;
+}
+
+/** The secrets an admin bound for an extension: encrypted at rest, never sent to a client. */
+export declare const cmsExtensionSecretsTable: TableLike;
+
+/** One row per installed extension: its version, what it was granted, and a newer version waiting for consent. */
+export declare const cmsExtensionsTable: TableLike;
+
+/** One entry per workspace, term (lower case) and target language. */
+export declare const cmsGlossaryTable: TableLike;
+
+/** The address each published document of a tree type had at its last publish, per locale. */
+export declare const cmsPathsTable: TableLike;
+
+/**
+ * One preview share: which variant, which revision (null = always the
+ * latest), until when, and whether it was revoked. Register it in the app's
+ * `databaseHandle` beside `cmsRevisionsTable`.
+ */
+export declare const cmsPreviewSharesTable: TableLike;
+
+/** One repeating live window per draft: its rule, and the occurrence armed last (-1: none yet). */
+export declare const cmsPublishSeriesTable: TableLike;
+
+export declare const cmsQualityExceptionsTable: TableLike;
+
+/** A former address and the document now answering it. */
+export declare const cmsRedirectsTable: TableLike;
+
+/**
+ * One row per reference a published variant makes: the source (type,
+ * document, variant, scope), where in its values the reference sits (`path`)
+ * and the target document. Tenant-scoped. Register it in the app's
+ * `databaseHandle` beside `cmsRevisionsTable`.
+ */
+export declare const cmsReferencesTable: TableLike;
+
+/** One variant in a release: publish its pinned revision, or unpublish it. */
+export declare const cmsReleaseItemsTable: TableLike;
+
+/**
+ * A named set of pinned revisions for ONE site and environment. Register it
+ * (with `cmsReleaseItemsTable`) in the app's `databaseHandle`.
+ */
+export declare const cmsReleasesTable: TableLike;
+
 export declare interface CmsRestOptions {
     readonly cms: CmsApi;
     readonly types: ReadonlyArray<ContentType>;
@@ -80,8 +655,123 @@ export declare interface CmsRestResponse {
     readonly body: unknown;
 }
 
+/**
+ * One review step on one variant and revision. `actorId` is who took the
+ * step. Register it in the app's `databaseHandle` beside `cmsRevisionsTable`
+ * when a content type requires review.
+ */
+export declare const cmsReviewsTable: TableLike;
+
+/**
+ * Every successful save of a draft writes ONE immutable row here: the
+ * validated field values, the content type, the document, the variant's scope
+ * and a number per variant (document + scope) starting at 1. Rows are never updated or
+ * deleted — a restore or a later edit writes a new revision. Tenant-scoped
+ * with the audit columns, like the content tables; the unique key makes a
+ * second writer of the same number fail instead of forking the history.
+ *
+ * Register it in the app's `databaseHandle` beside the content tables.
+ */
+export declare const cmsRevisionsTable: TableLike;
+
+/**
+ * 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()`).
+ */
+export declare interface CmsScope {
+    readonly site: string;
+    readonly environment: string;
+    /** A BCP 47 tag, e.g. `en-GB`. */
+    readonly locale: string;
+}
+
+export declare const cmsSearchTable: TableLike;
+
+export declare const cmsStewardshipTable: TableLike;
+
+/** Who is invited with which role. */
+export declare const cmsTeamInvitationsTable: TableLike;
+
+/** One row per workspace: the role a new editor gets, and the types whose publishing needs a review here. */
+export declare const cmsTeamTable: TableLike;
+
+/** 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;
+
+/**
+ * The fields two editors can type in together: plain text (`text` or
+ * `textarea`) the editor writes itself — not a derived or unique field (a
+ * slug), not a choice (a template), not rich text.
+ */
+export declare const collaborativeFields: (type: ContentType) => ReadonlyArray<string>;
+
+/** Effect form of {@link compareEnvironments}. */
+export declare const compareEnvironments: (...args: Parameters<typeof compareEnvironments_2>) => Effect<readonly EnvironmentDifference[], never, never>;
+
+/** How `to` differs from `from`, type by type. */
+declare const compareEnvironments_2: (store: DataStore, types: ReadonlyArray<ContentType>, pair: EnvironmentPair) => Promise<ReadonlyArray<EnvironmentDifference>>;
+
+/** 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;
+}
+
+/** Effect form of {@link consentToUpgrade}. */
+export declare const consentToUpgrade: (...args: Parameters<typeof consentToUpgrade_2>) => Effect<ExtensionChange, never, never>;
+
+/** Consent to what the waiting version adds, and move to it. */
+declare const consentToUpgrade_2: (tx: DataStore, extensionId: string, consent: ReadonlyArray<ExtensionCapability>) => Promise<ExtensionChange>;
+
+export declare const CONTENT_FORM_STRINGS: ContentFormStrings;
 
 /** The lifecycle states a content row moves through. */
 export declare const CONTENT_STATUSES: readonly ["draft", "published", "archived"];
@@ -103,28 +793,168 @@ 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>>;
 }
 
-/**
- * Raised by `saveDraft` when the caller supplies an explicit `id` that
- * already exists OUTSIDE the caller's scope (another tenant's row).
- * Refusing here keeps a caller-pinned id from ever updating — or, on a
- * store without DB-enforced PKs, overwriting — a foreign row.
- */
-export declare class ContentIdConflict extends ContentIdConflict_base {
+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;
 }
 
-declare const ContentIdConflict_base: Schema_2.TaggedErrorClass<ContentIdConflict, "ContentIdConflict", {
-    readonly _tag: Schema_2.tag<"ContentIdConflict">;
-} & {
-    contentType: typeof Schema_2.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;
+}>;
+
+/** Effect form of {@link contentHealth}. */
+export declare const contentHealth: (...args: Parameters<typeof contentHealth_2>) => Effect<readonly HealthFinding[], never, never>;
+
+/**
+ * What needs attention among the PUBLISHED documents of `types` in a site and
+ * environment: documents without an owner, reviews that are due, live
+ * variants linking to a document that is not live in that language, and
+ * languages missing or behind the source. Read through the caller's store, so
+ * a request store answers for its tenant. Reads every published row of the
+ * types — a report, not a hot path.
+ */
+declare const contentHealth_2: (store: DataStore, types: ReadonlyArray<ContentType>, place: Place_2, options: HealthOptions) => Promise<ReadonlyArray<HealthFinding>>;
+
+/**
+ * Raised by `saveDraft` when the caller supplies an explicit `id` that
+ * already exists OUTSIDE the caller's scope (another tenant's row).
+ * Refusing here keeps a caller-pinned id from ever updating — or, on a
+ * store without DB-enforced PKs, overwriting — a foreign row.
+ */
+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;
 }>;
 
@@ -142,8 +972,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 chainable read over one content type's published rows. */
@@ -156,6 +988,17 @@ export declare interface ContentQuery {
     all(): Promise<ReadonlyArray<Row>>;
     /** Resolve the first matching row, or null. */
     one(): Promise<Row | null>;
+    /**
+     * One page of matching rows in `id` order, after the row whose id is
+     * `after`. `next` is the id to pass for the following page, null on the
+     * last. Keyset, not offset: a row published or taken down between two
+     * requests neither repeats nor skips another. Replaces any `orderBy`,
+     * `limit` and `offset` on the query.
+     */
+    page(limit: number, after?: string): Promise<{
+        readonly items: ReadonlyArray<Row>;
+        readonly next: string | null;
+    }>;
 }
 
 export declare type ContentStatus = (typeof CONTENT_STATUSES)[number];
@@ -168,9 +1011,31 @@ export 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). */
@@ -186,11 +1051,86 @@ export 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
@@ -212,12 +1152,24 @@ export declare interface ContentTypeSpec {
  * published table (the one the rest of the app reads). Both carry the
  * lifecycle `status` column + audit timestamps and are reactive so
  * a publish wakes live consumer subscriptions. The draft table also
- * carries a nullable `publishAt` (scheduled publishing). A field marked
+ * carries nullable `publishAt` and `unpublishAt` (scheduled publishing and
+ * take-down). A field marked
  * `unique()` adds a composite `(tenantId, field)` DB UNIQUE to BOTH
  * tables — per-tenant uniqueness enforced by the database.
  */
 export declare const contentTypeToEntities: (ct: ContentType) => ContentEntities;
 
+export declare interface ContentUsage {
+    readonly documents: number;
+    readonly documentsByType: Readonly<Record<string, number>>;
+    readonly environments: ReadonlyArray<string>;
+}
+
+/** Effect form of {@link contentUsage}. */
+export declare const contentUsage: (...args: Parameters<typeof contentUsage_2>) => Effect<ContentUsage, never, never>;
+
+declare const contentUsage_2: (store: DataStore, types: ReadonlyArray<ContentType>, site: string) => Promise<ContentUsage>;
+
 /**
  * Raised by `validateContent` / `saveDraft` when a row violates the
  * content type's field rules (pattern / maxLength / typed kinds /
@@ -243,9 +1195,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
@@ -258,7 +1210,27 @@ 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>;
+
+/** Effect form of {@link copyEnvironment}. */
+export declare const copyEnvironment: (...args: Parameters<typeof copyEnvironment_2>) => Effect<CopyEnvironmentResult, never, never>;
+
+/**
+ * Fill `to` from `from`, within one site. Refused unless `to` holds no variant
+ * of these types yet — a copy never merges into, or overwrites, content that
+ * is already there.
+ */
+declare const copyEnvironment_2: (tx: DataStore, types: ReadonlyArray<ContentType>, pair: EnvironmentPair) => Promise<CopyEnvironmentResult>;
+
+export declare type CopyEnvironmentResult = {
+    readonly ok: true;
+    readonly variants: number;
+    readonly published: number;
+} | {
+    readonly ok: false;
+    readonly reason: 'targetNotEmpty' | 'sameEnvironment';
+    readonly variants: number;
+};
 
 /**
  * A standalone CMS client for build-time consumption (the blog
@@ -268,9 +1240,101 @@ export declare const contentViolations: (type: Pick<ContentType, "name" | "field
 export declare const createCmsClient: (config: {
     store: DataStore;
     types: ReadonlyArray<ContentType>;
+    scope: CmsScope;
     secret?: string;
 }) => CmsApi;
 
+/** Effect form of {@link createPreviewShare}. */
+export declare const createPreviewShare: (...args: Parameters<typeof createPreviewShare_2>) => Effect<{
+    readonly share: Row;
+    readonly token: string;
+}, ContentNotFound | PreviewShareRejected, never>;
+
+/**
+ * Share one of the caller's drafts. Returns the stored share and the link
+ * token — the only time the token exists in the clear; hand it to the visitor
+ * as part of a URL. Throws `ContentNotFound` when the draft is not the
+ * caller's in `scope`, and `PreviewShareRejected` for an expiry that is not in
+ * the future or lies more than `MAX_PREVIEW_SHARE_DAYS` ahead.
+ */
+declare const createPreviewShare_2: (store: DataStore, type: ContentType, variantId: string, scope: CmsScope, options: CreatePreviewShareOptions) => Promise<{
+    readonly share: Row;
+    readonly token: string;
+}>;
+
+export declare interface CreatePreviewShareOptions {
+    /** `pinned` shows the revision the draft has now; `latest` follows every save. */
+    readonly revision: 'pinned' | 'latest';
+    readonly expiresAt: Date;
+    readonly label?: string;
+    /** The clock (tests). */
+    readonly now?: Date;
+}
+
+/** Effect form of {@link createRelease}. */
+export declare const createRelease: (...args: Parameters<typeof createRelease_2>) => Effect<Readonly<Record<string, unknown>>, never, never>;
+
+/** Create an empty release for one site and environment. */
+declare const createRelease_2: (store: DataStore, input: {
+    readonly name: string;
+    readonly site: string;
+    readonly environment: string;
+}) => Promise<Row>;
+
+export declare type DecideExceptionResult = {
+    readonly ok: true;
+    readonly state: 'approved' | 'rejected' | 'withdrawn';
+} | {
+    readonly ok: false;
+    readonly reason: 'notFound' | 'notOpen' | 'selfApproval' | 'notRequester';
+};
+
+export declare interface DecideOptions {
+    /** The revision the reviewer looked at. */
+    readonly revisionId: string;
+    readonly actorId: string;
+    readonly note?: string;
+    /** Let the person who asked approve their own request. Off by default. */
+    readonly allowSelfApproval?: boolean;
+}
+
+/** Effect form of {@link decideQualityException}. */
+export declare const decideQualityException: (...args: Parameters<typeof decideQualityException_2>) => Effect<DecideExceptionResult, never, never>;
+
+/**
+ * Decide on an exception: approve or reject an open request (never your own),
+ * or withdraw one — the requester their open request, anyone an approved one
+ * (the finding blocks again at once).
+ */
+declare const decideQualityException_2: (tx: DataStore, exceptionId: string, input: {
+    readonly decision: "approve" | "reject" | "withdraw";
+    readonly actorId: string;
+    readonly note?: string;
+}, now?: Date) => Promise<DecideExceptionResult>;
+
+/** 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;
+
+/**
+ * Check a blueprint and order its entries so every referenced entry comes
+ * before the entries that reference it. Throws `BlueprintInvalid` for a key
+ * used twice, a reference to no entry, or entries that reference each other
+ * in a circle.
+ */
+export declare const defineBlueprint: (spec: Blueprint) => Blueprint;
+
+/** 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;
+
 export declare const defineContentType: (spec: ContentTypeSpec) => ContentType;
 
 /**
@@ -292,11 +1356,404 @@ 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;
+
+export declare const describeFailure: (err: unknown) => 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';
+    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>;
+
+/** Effect form of {@link dropFromSearch}. */
+export declare const dropFromSearch: (...args: Parameters<typeof dropFromSearch_2>) => Effect<void, never, never>;
+
+/** Remove a variant from the search, for the given stages. */
+declare const dropFromSearch_2: (tx: DataStore, type: ContentType, variantId: string, stages: ReadonlyArray<"draft" | "published">) => Promise<void>;
+
+export declare interface DuplicateDocument {
+    readonly id: string;
+    readonly documentId: string;
+    readonly title: string;
+    readonly status: string;
+}
+
+export declare interface DuplicateGroup {
+    readonly fingerprint: string;
+    /** Oldest first: the first is the one to keep unless someone decides otherwise. */
+    readonly documents: ReadonlyArray<DuplicateDocument>;
+}
+
+/** Effect form of {@link duplicateGroups}. */
+export declare const duplicateGroups: (...args: Parameters<typeof duplicateGroups_2>) => Effect<readonly DuplicateGroup[], never, never>;
+
+/** The drafts of `type` in `scope` whose `field` holds the same file, grouped. Archived drafts are left out. */
+declare const duplicateGroups_2: (store: DataStore, type: ContentType, scope: CmsScope, options: {
+    readonly field: string;
+    readonly fingerprint: Fingerprint;
+    readonly titleField?: string;
+}) => Promise<ReadonlyArray<DuplicateGroup>>;
+
+/** 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 EnvironmentDifference {
+    readonly contentType: string;
+    /** Documents (with a variant) in `from` only, and in `to` only. */
+    readonly onlyInFrom: number;
+    readonly onlyInTo: number;
+    /** Live in both, with different published values. */
+    readonly differing: ReadonlyArray<{
+        readonly documentId: string;
+        readonly locale: string;
+        readonly title: string;
+    }>;
+}
+
+export declare interface EnvironmentPair {
+    readonly site: string;
+    readonly from: string;
+    readonly to: string;
+}
+
+export declare type ExceptionState = 'requested' | 'approved' | 'rejected' | 'withdrawn' | 'expired';
+
+export declare interface Experiment {
+    readonly id: string;
+    readonly name: string;
+    readonly contentType: string;
+    readonly documentId: string;
+    readonly locale: string;
+    readonly status: 'running' | 'stopped';
+    readonly share: number;
+    readonly overrides: Readonly<Record<string, string>>;
+    readonly goal: string;
+    /** Null for an experiment started before hypotheses were asked for. */
+    readonly hypothesis: string | null;
+    readonly guardrailMaxDrop: number | null;
+    readonly startedAt: Date;
+    readonly stoppedAt: Date | null;
+    /** Version A: the published revision it was started on (null before lineage was recorded). */
+    readonly revisionId: string | null;
+    readonly adoptedReleaseId: string | null;
+    readonly adoptedRevisionId: string | null;
+}
+
+/** Effect form of {@link experimentById}. */
+export declare const experimentById: (...args: Parameters<typeof experimentById_2>) => Effect<Experiment | null, never, never>;
+
+/** One experiment by id, or null. */
+declare const experimentById_2: (store: DataStore, experimentId: string) => Promise<Experiment | null>;
+
+/** Fields version B may override: the type's own text fields, not derived ones (a slug follows its title). */
+export declare const experimentFields: (type: ContentType) => ReadonlyArray<string>;
+
+export declare interface ExperimentLineage {
+    /** Version A: the published revision the experiment was started on. */
+    readonly startedOn: string | null;
+    /** Version B: that revision with these fields replaced. */
+    readonly overrides: Readonly<Record<string, string>>;
+    /** Per delivered revision and version, the readers counted (a publish during the experiment adds a row). */
+    readonly delivered: ReadonlyArray<{
+        readonly revisionId: string | null;
+        readonly variant: Variant;
+        readonly readers: number;
+    }>;
+    /** The adoption, when version B went into a release; `releaseStatus` follows the release. */
+    readonly adopted: {
+        readonly releaseId: string;
+        readonly revisionId: string;
+        readonly releaseStatus: string;
+    } | null;
+}
+
+/** Effect form of {@link experimentLineage}. */
+export declare const experimentLineage: (...args: Parameters<typeof experimentLineage_2>) => Effect<ExperimentLineage | null, never, never>;
+
+/** Where every delivery of an experiment came from — revision, version, adoption. */
+declare const experimentLineage_2: (store: DataStore, experimentId: string) => Promise<ExperimentLineage | null>;
+
+export declare interface ExperimentResults {
+    readonly A: VariantResult;
+    readonly B: VariantResult;
+    /** B's rate relative to A's (0.25 = a quarter more); null while A has no conversions. */
+    readonly lift: number | null;
+    /** Two-sided p-value of the difference in rates (two-proportion z-test); null without readers in both. */
+    readonly pValue: number | null;
+    /** At least `MIN_READERS` per version and p below 0.05 — before that the difference may be noise. */
+    readonly conclusive: boolean;
+    /** The guardrail, and whether B fell below it (judged from `MIN_READERS` per version on). */
+    readonly guardrail: {
+        readonly maxDrop: number | null;
+        readonly breached: boolean;
+    };
+}
+
+/** Effect form of {@link experimentResults}. */
+export declare const experimentResults: (...args: Parameters<typeof experimentResults_2>) => Effect<ExperimentResults, never, never>;
+
+/** Per version: readers, conversions and rate, the lift of B, and whether the difference is yet more than noise. */
+declare const experimentResults_2: (store: DataStore, experimentId: string) => Promise<ExperimentResults>;
+
+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}`;
+
+export declare type ExtensionChange = {
+    readonly ok: true;
+    readonly installed: InstalledExtension;
+} | {
+    readonly ok: false;
+    readonly reason: 'invalidManifest';
+    readonly problems: ReadonlyArray<string>;
+} | {
+    readonly ok: false;
+    readonly reason: 'consentIncomplete';
+    readonly missing: ReadonlyArray<ExtensionCapability>;
+} | {
+    readonly ok: false;
+    readonly reason: 'alreadyInstalled' | 'notInstalled' | 'notNewer' | 'nothingPending' | 'nothingToRollBack';
+};
+
+/** What the host lends an extension; the sandbox decides whether it may use it. */
+export declare interface ExtensionHost {
+    readonly readContent: (type: string, id: string) => Promise<Readonly<Record<string, unknown>> | null>;
+    /** A type's drafts as the host lends them (it decides how many). */
+    readonly listContent: (type: string) => Promise<ReadonlyArray<Readonly<Record<string, unknown>>>>;
+    /** How many drafts a type has — all of them, where `listContent` may lend only some. */
+    readonly countContent: (type: string) => Promise<number>;
+    /** The values a revision holds (what a release publishes), or null. */
+    readonly readRevision: (revisionId: string) => Promise<Readonly<Record<string, unknown>> | null>;
+    readonly writeContent: (type: string, id: string, values: Readonly<Record<string, unknown>>) => Promise<void>;
+    readonly fetch: (url: string, init?: RequestInit) => Promise<Response>;
+    /** The secret bound under `name`, or undefined. */
+    readonly secret: (name: string) => Promise<string | undefined>;
+}
+
+/** 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>;
+    }>]>>>;
+}>;
+
+export declare type ExtensionRemoval = {
+    readonly ok: true;
+    readonly data: ReadonlyArray<{
+        readonly key: string;
+        readonly value: unknown;
+    }>;
+} | {
+    readonly ok: false;
+    readonly reason: 'notInstalled';
+};
+
+/** What an installed extension's code gets. */
+export declare interface ExtensionSandbox {
+    readonly extensionId: string;
+    readonly readContent: ExtensionHost['readContent'];
+    readonly listContent: ExtensionHost['listContent'];
+    readonly countContent: ExtensionHost['countContent'];
+    readonly readRevision: ExtensionHost['readRevision'];
+    readonly writeContent: ExtensionHost['writeContent'];
+    readonly fetch: ExtensionHost['fetch'];
+    readonly secret: (name: string) => Promise<string | undefined>;
+    /** Its settings as the admin set them (defaults for the rest). */
+    readonly settings: () => Promise<Readonly<Record<string, ExtensionSettingValue>>>;
+    /** Its own data. */
+    readonly data: {
+        readonly get: (key: string) => Promise<unknown>;
+        readonly set: (key: string, value: unknown) => Promise<void>;
+    };
+}
+
+/**
+ * The sandbox for `installed`: content, the network and secrets through the
+ * host, each only when granted; every refusal is `ExtensionAccessDenied`
+ * (thrown). Egress is HTTPS to a granted host only.
+ */
+export declare const extensionSandbox: (store: DataStore, installed: InstalledExtension, host: ExtensionHost) => ExtensionSandbox;
+
+/** Effect form of {@link extensionSecret}. */
+export declare const extensionSecret: (...args: Parameters<typeof extensionSecret_2>) => Effect<string | undefined, never, never>;
+
+/** The value of a bound secret, for the host — never for a client. */
+declare const extensionSecret_2: (store: DataStore, extensionId: string, name: string) => Promise<string | undefined>;
+
+/** 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>;
+};
+
+/** Effect form of {@link extensionSettings}. */
+export declare const extensionSettings: (...args: Parameters<typeof extensionSettings_2>) => Effect<Readonly<Record<string, ExtensionSettingValue>> | null, never, never>;
+
+/** An installed extension's settings, with defaults for what was never set. */
+declare const extensionSettings_2: (store: DataStore, extensionId: string) => Promise<Readonly<Record<string, ExtensionSettingValue>> | null>;
+
+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;
@@ -307,12 +1764,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).
@@ -327,10 +1792,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]`. */
@@ -340,6 +1824,75 @@ export declare interface FieldViolation {
     readonly message: string;
 }
 
+/** How to fingerprint a stored value (a media key); null when it cannot be read. */
+export declare type Fingerprint = (value: string) => Promise<string | null>;
+
+/**
+ * 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>;
+
+/** Effect form of {@link glossary}. */
+export declare const glossary: (...args: Parameters<typeof glossary_2>) => Effect<readonly GlossaryEntry[], never, never>;
+
+/** The workspace's entries, by term; for one target language when given. */
+declare const glossary_2: (store: DataStore, tenantId: string, locale?: string) => Promise<ReadonlyArray<GlossaryEntry>>;
+
+export declare interface GlossaryEntry {
+    readonly id: string;
+    /** The term as written in the source language. */
+    readonly term: string;
+    /** The target language. */
+    readonly locale: string;
+    /** How it is written there; null: it stays as it is (a brand name). */
+    readonly translation: string | null;
+    /** Translations that must not be used. */
+    readonly forbidden: ReadonlyArray<string>;
+    readonly note: string | null;
+}
+
+export declare interface GlossaryInput {
+    readonly term: string;
+    readonly locale: string;
+    readonly translation?: string | null;
+    readonly forbidden?: ReadonlyArray<string>;
+    readonly note?: string | null;
+}
+
+/** What is wrong with an entry; empty when nothing is. */
+export declare const glossaryInputProblems: (input: GlossaryInput) => ReadonlyArray<string>;
+
+/** The forbidden translations `text` (in the target language) uses, per term. */
+export declare const glossaryProblems: (text: string, entries: ReadonlyArray<GlossaryEntry>) => ReadonlyArray<{
+    readonly term: string;
+    readonly found: string;
+    readonly use: string | null;
+}>;
+
+/** The purposes whose current version the reader allowed. */
+export declare const grantedPurposes: (purposes: ReadonlyArray<ConsentPurpose>, choices: ConsentChoices) => ReadonlySet<string>;
+
+/** Effect form of {@link hadAddress}. */
+export declare const hadAddress: (...args: Parameters<typeof hadAddress_2>) => Effect<boolean, never, never>;
+
+/**
+ * Whether `path` was an address of a document of `type` in `scope` — its last
+ * published address, or one a redirect points from — whatever answers it now.
+ * Ask it once `cms.route` found no live page: then the document is no longer
+ * live and the address is gone.
+ */
+declare const hadAddress_2: (store: DataStore, type: string, path: string, scope: CmsScope, tenantId?: unknown) => Promise<boolean>;
+
 /**
  * Handle one CMS REST request. Returns 401 on a missing/unknown key,
  * 403 when the key isn't scoped to the requested type, 404 for unknown
@@ -348,152 +1901,1482 @@ export declare interface FieldViolation {
  */
 export declare const handleCmsRest: (req: CmsRestRequest, options: CmsRestOptions) => Promise<CmsRestResponse>;
 
-/**
- * List-view configuration for the consuming editor/template: which
- * columns its list page shows and the default sort. Validated by
- * `defineContentType` — every referenced name must be a declared field
- * or a lifecycle column, so a typo fails at definition time instead of
- * rendering an empty column.
- */
-export declare interface ListConfig {
-    readonly columns: ReadonlyArray<string>;
-    readonly defaultSort?: {
-        readonly field: string;
-        readonly dir: 'asc' | 'desc';
-    };
+/** 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;
+
+/** One thing that needs attention. */
+export declare interface HealthFinding {
+    readonly kind: 'noOwner' | 'reviewDue' | 'linksToUnpublished' | 'translationMissing' | 'translationOutdated';
+    readonly contentType: string;
+    readonly documentId: string;
+    /** The language it concerns; null when it concerns the whole document. */
+    readonly locale: string | null;
+    /** The document's title in the source language (else any), for a list. */
+    readonly title: string;
+    /** `linksToUnpublished`: the fields holding the links; `translationOutdated`: the source fields changed since. */
+    readonly detail: ReadonlyArray<string>;
 }
 
-/** Cap a string field's length. Past `value` the editor renders a textarea. */
-export declare const maxLength: (value: number) => FieldRefinement;
+export declare interface HealthOptions {
+    readonly sourceLocale: string;
+    /** Every language the site has, the source included. */
+    readonly locales: ReadonlyArray<string>;
+    readonly now?: Date;
+}
 
-/** The media field names on a content type (top level) — handy for a
- *  consumer that wants to know whether resolution is even needed. */
-export declare const mediaFields: (type: Pick<ContentType, "fields">) => ReadonlyArray<string>;
+export declare interface HtmlImportFinding {
+    readonly kind: 'unsupportedTag' | 'externalLink' | 'image';
+    /** The tag, the link's address or the image's source. */
+    readonly detail: string;
+}
 
-/**
- * Resolve a stored media KEY to a served URL. The app builds this from its
- * storage layer, e.g. `(key) => Effect.runPromise(storage.getUrl(key, { tenantId }))`
- * or, for an access-checked URL, `(key) => Effect.runPromise(storage.mintUrl(key, subject))`.
- * Returning `null` leaves the field as its stored key (unresolved).
- */
-export declare type MediaResolver = (key: string) => Promise<string | null>;
+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;
+}
 
-/** Constrain a string field to a regex (source form, validated on save). */
-export declare const pattern: (re: RegExp) => FieldRefinement;
+export declare interface HtmlImportResult {
+    readonly document: RichDocument;
+    readonly findings: ReadonlyArray<HtmlImportFinding>;
+}
+
+/** Effect form of {@link indexForSearch}. */
+export declare const indexForSearch: (...args: Parameters<typeof indexForSearch_2>) => Effect<void, never, never>;
+
+/** Write a variant's text for one stage, in the caller's transaction. A type without `search` writes nothing. */
+declare const indexForSearch_2: (tx: DataStore, type: ContentType, row: Row, scope: CmsScope, stage: "draft" | "published") => Promise<void>;
+
+/** 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;
+
+/** An installed extension as the editor shows it. */
+export declare interface InstalledExtension {
+    readonly extensionId: string;
+    /** The version running now. */
+    readonly manifest: CmsExtensionManifest;
+    readonly granted: ReadonlyArray<ExtensionCapability>;
+    /** A newer version waiting for consent, and what it would add. */
+    readonly pending: {
+        readonly manifest: CmsExtensionManifest;
+        readonly adds: ReadonlyArray<ExtensionCapability>;
+    } | null;
+    /** The version a rollback returns to, or null. */
+    readonly previous: CmsExtensionManifest | null;
+}
+
+/** Effect form of {@link installedExtension}. */
+export declare const installedExtension: (...args: Parameters<typeof installedExtension_2>) => Effect<InstalledExtension | null, never, never>;
+
+/** One installed extension, or null. */
+declare const installedExtension_2: (store: DataStore, extensionId: string) => Promise<InstalledExtension | null>;
+
+/** Effect form of {@link installedExtensions}. */
+export declare const installedExtensions: (...args: Parameters<typeof installedExtensions_2>) => Effect<readonly InstalledExtension[], never, never>;
+
+/** Every installed extension, by id. */
+declare const installedExtensions_2: (store: DataStore) => Promise<ReadonlyArray<InstalledExtension>>;
+
+/** Effect form of {@link installExtension}. */
+export declare const installExtension: (...args: Parameters<typeof installExtension_2>) => Effect<ExtensionChange, never, never>;
+
+/** Install `manifest`, granting it `consent` — which must cover every capability it asks for. */
+declare const installExtension_2: (tx: DataStore, manifest: CmsExtensionManifest, consent: ReadonlyArray<ExtensionCapability>) => Promise<ExtensionChange>;
+
+/** Effect form of {@link invitedRole}. */
+export declare const invitedRole: (...args: Parameters<typeof invitedRole_2>) => Effect<string | null, never, never>;
+
+/** The role `email` was invited with, or null. */
+declare const invitedRole_2: (store: DataStore, tenantId: string, email: string) => Promise<string | null>;
+
+/** Effect form of {@link inviteToTeam}. */
+export declare const inviteToTeam: (...args: Parameters<typeof inviteToTeam_2>) => Effect<"present" | "changed" | "invited", never, never>;
+
+/**
+ * Invite `email` with `role`, in the caller's transaction: `invited` for a new
+ * address, `changed` when it was invited with another role, `present` when
+ * nothing changed. Check it with `teamProblems({ members: [{ email, role }] })` first.
+ */
+declare const inviteToTeam_2: (tx: DataStore, tenantId: string, email: string, role: string) => Promise<"invited" | "changed" | "present">;
+
+/** 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. */
+export 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
+ * `defineContentType` — every referenced name must be a declared field
+ * or a lifecycle column, so a typo fails at definition time instead of
+ * rendering an empty column.
+ */
+export declare interface ListConfig {
+    readonly columns: ReadonlyArray<string>;
+    readonly defaultSort?: {
+        readonly field: string;
+        readonly dir: 'asc' | 'desc';
+    };
+}
+
+/** Effect form of {@link listExperiments}. */
+export declare const listExperiments: (...args: Parameters<typeof listExperiments_2>) => Effect<readonly Experiment[], never, never>;
+
+/** Every experiment of the caller's tenant, newest first. */
+declare const listExperiments_2: (store: DataStore) => Promise<ReadonlyArray<Experiment>>;
+
+/** 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;
+
+/** Effect form of {@link listPreviewShares}. */
+export declare const listPreviewShares: (...args: Parameters<typeof listPreviewShares_2>) => Effect<readonly Readonly<Record<string, unknown>>[], ContentNotFound | PreviewShareRejected, never>;
+
+/** The caller's shares of one document (every variant), newest first. */
+declare const listPreviewShares_2: (store: DataStore, type: ContentType, documentId: string) => Promise<ReadonlyArray<Row>>;
+
+/** Effect form of {@link listRedirects}. */
+export declare const listRedirects: (...args: Parameters<typeof listRedirects_2>) => Effect<readonly Readonly<Record<string, unknown>>[], never, never>;
+
+/** Every redirect in `scope`, for inspection. */
+declare const listRedirects_2: (store: DataStore, type: string, scope: CmsScope) => Promise<ReadonlyArray<Row>>;
+
+/** Effect form of {@link listReleaseItems}. */
+export declare const listReleaseItems: (...args: Parameters<typeof listReleaseItems_2>) => Effect<readonly Readonly<Record<string, unknown>>[], never, never>;
+
+/** A release's entries in the order they apply. */
+declare const listReleaseItems_2: (store: DataStore, releaseId: string) => Promise<ReadonlyArray<Row>>;
+
+/** Effect form of {@link listReleases}. */
+export declare const listReleases: (...args: Parameters<typeof listReleases_2>) => Effect<readonly Readonly<Record<string, unknown>>[], never, never>;
+
+/** The releases of one site and environment, newest first. */
+declare const listReleases_2: (store: DataStore, where: {
+    readonly site: string;
+    readonly environment: string;
+}) => Promise<ReadonlyArray<Row>>;
+
+/** Effect form of {@link listRevisions}. */
+export declare const listRevisions: (...args: Parameters<typeof listRevisions_2>) => Effect_2.Effect<readonly Readonly<Record<string, unknown>>[], never, never>;
+
+/**
+ * Every saved revision of one document's variant in `scope`, newest first.
+ * Revisions are immutable: a later save or a restore appends, it never
+ * rewrites.
+ */
+declare const listRevisions_2: (store: DataStore, type: ContentType, documentId: string, scope: CmsScope) => Promise<ReadonlyArray<Row>>;
+
+/** The texts a save materializes: those belonging to the draft's current revision. */
+export declare interface LiveDraftTexts {
+    /** Field → the merged text. */
+    readonly values: ReadonlyMap<string, string>;
+    readonly rows: ReadonlyArray<Row>;
+}
+
+/** Effect form of {@link liveDraftTexts}. */
+export declare const liveDraftTexts: (...args: Parameters<typeof liveDraftTexts_2>) => Effect<LiveDraftTexts, ContentNotFound, never>;
+
+declare const liveDraftTexts_2: (store: DataStore, draft: Row) => Promise<LiveDraftTexts>;
+
+/** 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 longest an exception may run. */
+export declare const MAX_EXCEPTION_DAYS = 90;
+
+/** The deepest a list item may sit (0 is the top). */
+export declare const MAX_LIST_LEVEL = 3;
+
+export declare const MAX_OCCURRENCES = 100;
+
+/** The longest a preview link may live. */
+export declare const MAX_PREVIEW_SHARE_DAYS = 30;
+
+/** Cap a string field's length. Past `value` the editor renders a textarea. */
+export declare const maxLength: (value: number) => FieldRefinement;
+
+/** The media field names on a content type (top level) — handy for a
+ *  consumer that wants to know whether resolution is even needed. */
+export declare const mediaFields: (type: Pick<ContentType, "fields">) => ReadonlyArray<string>;
+
+/**
+ * Resolve a stored media KEY to a served URL. The app builds this from its
+ * storage layer, e.g. `(key) => Effect.runPromise(storage.getUrl(key, { tenantId }))`
+ * or, for an access-checked URL, `(key) => Effect.runPromise(storage.mintUrl(key, subject))`.
+ * Returning `null` leaves the field as its stored key (unresolved).
+ */
+export declare type MediaResolver = (key: string) => Promise<string | null>;
+
+/** Adjacent text runs with the same marks become one; empty text runs go. */
+export declare const mergeInline: (content: ReadonlyArray<RichInline>) => ReadonlyArray<RichInline>;
+
+/** Readers per version before a result is called at all. */
+export declare const MIN_READERS = 100;
+
+/** Where this calendar month (UTC) began. */
+export declare const monthStart: (now?: Date) => Date;
+
+/**
+ * The fields a draft typed in together may have moved on in without anyone
+ * losing an edit: the texts in `shared`, and every field derived from one of
+ * them (a slug from its title).
+ */
+export declare const movedTogether: (type: ContentType, shared: ReadonlySet<string>) => ReadonlySet<string>;
+
+/** `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>;
+
+/** Effect form of {@link openDraftTexts}. */
+export declare const openDraftTexts: (...args: Parameters<typeof openDraftTexts_2>) => Effect<readonly Readonly<Record<string, unknown>>[], ContentNotFound, never>;
+
+/**
+ * Start typing together in a draft: every collaborative field gets a text
+ * that belongs to the draft's current revision — kept where there is one,
+ * started from the draft's value where there is none or where the draft moved
+ * on without it. Idempotent; two editors opening at once end with one text per
+ * field. `ContentNotFound` for a draft the caller cannot see. In the caller's
+ * transaction.
+ */
+declare const openDraftTexts_2: (tx: DataStore, type: ContentType, draftId: string) => Promise<ReadonlyArray<Row>>;
+
+/** 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;
+}
+
+declare type Place = Pick<CmsScope, 'site' | 'environment'>;
+
+declare type Place_2 = Pick<CmsScope, 'site' | 'environment'>;
+
+/** The document's text, one line per block — for excerpts and search. */
+export declare const plainTextOf: (doc: RichDocument) => string;
+
+/** Effect form of {@link planBlueprint}. */
+export declare const planBlueprint: (...args: Parameters<typeof planBlueprint_2>) => Effect<BlueprintPlan, ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch | ReviewRequired | ReferenceUnavailable | BlueprintInvalid, never>;
+
+/**
+ * What provisioning `blueprint` into `target` would do, step by step: which
+ * documents the workspace has already and which would be created (and
+ * whether published). Reads only. Throws `BlueprintInvalid` when an entry
+ * names a type, field or template the app does not have.
+ */
+declare const planBlueprint_2: (store: DataStore, types: ReadonlyArray<ContentType>, blueprint: Blueprint, target: BlueprintTarget) => Promise<BlueprintPlan>;
+
+/** Effect form of {@link planBlueprintTeam}. */
+export declare const planBlueprintTeam: (...args: Parameters<typeof planBlueprintTeam_2>) => Effect<TeamPlan, never, never>;
+
+/** What provisioning the team would do. Reads only. */
+declare const planBlueprintTeam_2: (store: DataStore, tenantId: string, team: BlueprintTeam) => Promise<TeamPlan>;
+
+/** Effect form of {@link planBulk}. */
+export declare const planBulk: (...args: Parameters<typeof planBulk_2>) => Effect<readonly PlannedItem[], ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch | ReviewRequired | ReferenceUnavailable, never>;
+
+/** The dry run: what `action` would do to each item, changing nothing. */
+declare const planBulk_2: (store: DataStore, types: ReadonlyArray<ContentType>, place: Place, action: BulkAction, items: ReadonlyArray<BulkItem>) => Promise<ReadonlyArray<PlannedItem>>;
+
+export declare interface PlannedItem extends BulkItem {
+    readonly documentId: string | null;
+    readonly title: string;
+    /** For a publish: the revision the dry run saw, which the run publishes. */
+    readonly revisionId: string | null;
+    readonly disposition: 'ready' | 'unchanged' | 'blocked';
+    readonly reason: BlockReason | null;
+    /** For `referenceUnavailable`: the fields and why (`sections[0].props.image: blocked`); for
+     *  `incomplete`: the empty fields publishing needs. */
+    readonly detail: ReadonlyArray<string>;
+}
+
+/** Effect form of {@link planPromotion}. */
+export declare const planPromotion: (...args: Parameters<typeof planPromotion_2>) => Effect<readonly PromotionItem[], ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch | ReleaseNotEditable | ReviewRequired | ReferenceUnavailable, never>;
+
+/** What promoting `from` into `to` would change, per document and language. */
+declare const planPromotion_2: (store: DataStore, types: ReadonlyArray<ContentType>, pair: EnvironmentPair) => Promise<ReadonlyArray<PromotionItem>>;
+
+/** A verified preview claim. */
+export declare interface PreviewClaim {
+    readonly type: string;
+    readonly id: 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;
+};
+
+/**
+ * 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"]>;
+}>;
+
+/** Mint a signed preview token for a draft row. */
+export declare const previewToken: (type: string, id: string, options?: {
+    ttlSeconds?: number;
+    secret?: string;
+}) => string;
+
+/** Effect form of {@link promote}. */
+export declare const promote: (...args: Parameters<typeof promote_2>) => Effect<PromotionResult, ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch | ReleaseNotEditable | ReviewRequired | ReferenceUnavailable, never>;
+
+/**
+ * Promote the chosen documents from `pair.from` into `pair.to` as one release
+ * named `name`. Refuses (writing nothing) when an item is blocked, or not in
+ * the plan (not live in `from`, or live there unchanged); a failing check inside the release (review, availability,
+ * required fields) throws like any release publish — run it in a transaction.
+ */
+declare const promote_2: (tx: DataStore, types: ReadonlyArray<ContentType>, pair: EnvironmentPair, selections: ReadonlyArray<PromotionSelection>, options: {
+    readonly name: string;
+}) => Promise<PromotionResult>;
+
+export declare interface PromotionItem {
+    readonly contentType: string;
+    readonly documentId: string;
+    readonly locale: string;
+    readonly title: string;
+    readonly change: 'new' | 'changed' | 'blocked';
+}
+
+export declare type PromotionResult = {
+    readonly ok: true;
+    readonly releaseId: string;
+    readonly promoted: number;
+} | {
+    readonly ok: false;
+    readonly reason: 'nothingSelected' | 'blocked' | 'notInPlan';
+    readonly items: ReadonlyArray<PromotionSelection>;
+};
+
+export declare interface PromotionSelection {
+    readonly contentType: string;
+    readonly documentId: string;
+    readonly locale: string;
+}
+
+/** The hash an operation keeps of its prompt: enough to tell two prompts apart, nothing to read back. */
+export declare const promptHash: (prompt: string) => string;
+
+/** Effect-native `publish` (see {@link saveDraftEffect}). */
+export declare const publish: (store: DataStore, type: ContentType, id: string, scope: CmsScope, options?: PublishOptions) => Effect_2.Effect<Row, ContentNotFound | RevisionMismatch | ReviewRequired | ReferenceUnavailable | ContentValidationFailed>;
+
+/** Effect form of {@link publishDue}. */
+export declare const publishDue: (...args: Parameters<typeof publishDue_2>) => Effect<readonly string[], never, never>;
+
+/**
+ * Publish every draft of `type` whose scheduled `publishAt` has passed
+ * (and that is still a draft). Returns the ids that were published. A
+ * driver calls this on an interval from a `*.cron.tsx` schedule (see the
+ * README/docs recipe) — it is idempotent: `publish` flips the draft
+ * `status` to `'published'`, so a row is never double-published, and
+ * `publishAt` is cleared so a later re-save doesn't spuriously re-fire.
+ *
+ * Runs over the store it is handed: a request-scoped store publishes one
+ * tenant's due drafts; a background/root store sweeps every tenant. It opens
+ * one transaction per row, so hand it a store that is NOT already inside a
+ * transaction (a schedule's `app.store`, not a mutation's `ctx.store`).
+ */
+declare const publishDue_2: (store: DataStore, type: ContentType, now?: Date) => Promise<ReadonlyArray<string>>;
+
+/** Effect form of {@link publishDueReleases} — a failing release is marked `failed`, never an error. */
+export declare const publishDueReleases: (...args: Parameters<typeof publishDueReleases_2>) => Effect<readonly string[], never, never>;
+
+/**
+ * Take every scheduled release that is due live, each in its own transaction.
+ * A release is CLAIMED by a conditional update (`scheduled` → a fresh fencing
+ * token) inside that transaction, so a second scheduler run — another replica,
+ * a retry — finds nothing to take. A release that fails is marked `failed`
+ * with the reason and its pinned content stays as it was. Returns the ids
+ * that went live. Hand it a store outside any transaction (a schedule's
+ * `app.store`).
+ */
+declare const publishDueReleases_2: (store: DataStore, types: ReadonlyArray<ContentType>, now?: Date) => Promise<ReadonlyArray<string>>;
+
+/** Options for {@link publish}. */
+export declare interface PublishOptions {
+    /** Publish only if the draft still points at THIS revision — the one the
+     *  editor reviewed. A newer save in between throws `RevisionMismatch`
+     *  instead of publishing content nobody looked at. */
+    readonly revisionId?: string;
+}
+
+/** Effect form of {@link publishRelease}. */
+export declare const publishRelease: (...args: Parameters<typeof publishRelease_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound | ReleaseNotEditable | ReviewRequired | ReferenceUnavailable, never>;
+
+/**
+ * Publish every entry of a release — in the CALLER'S transaction, so either
+ * all of them go live or, when one fails, none does. Records what each variant
+ * showed before (for rollback) and marks the release `published`. Throws
+ * `ReleaseNotEditable` for a release that is already published or failed.
+ */
+declare const publishRelease_2: (tx: DataStore, types: ReadonlyArray<ContentType>, releaseId: string, now?: Date) => Promise<Row>;
+
+/** Effect-native `publishRevision` (see {@link saveDraftEffect}). */
+export declare const publishRevision: (tx: DataStore, type: ContentType, id: string, scope: CmsScope, revisionId: string, origin?: ChangeOrigin) => Effect_2.Effect<Row, ContentNotFound | RevisionMismatch | ReviewRequired | ReferenceUnavailable | ContentValidationFailed>;
+
+/** A series as the editor shows it. */
+export declare interface PublishSeries {
+    readonly id: string;
+    readonly rule: RecurrenceRule;
+    readonly occurrences: ReadonlyArray<Occurrence>;
+    /** The index (into `occurrences`) armed on the draft now, or -1. */
+    readonly armed: number;
+    readonly state: 'running' | 'done';
+}
+
+/**
+ * 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>;
+
+export declare interface QualityException {
+    readonly id: string;
+    readonly ruleId: string;
+    readonly reason: string;
+    readonly state: ExceptionState;
+    readonly requestedBy: string;
+    readonly requestedAt: Date;
+    readonly decidedBy: string | null;
+    readonly note: string | null;
+    readonly expiresAt: Date;
+}
+
+/** Effect form of {@link qualityExceptions}. */
+export declare const qualityExceptions: (...args: Parameters<typeof qualityExceptions_2>) => Effect<readonly QualityException[], never, never>;
+
+/** Every exception asked for on a variant, newest first, with its state today. */
+declare const qualityExceptions_2: (store: DataStore, type: ContentType, variantId: string, scope: CmsScope, now?: Date) => Promise<ReadonlyArray<QualityException>>;
+
+export declare interface QualityFinding {
+    readonly ruleId: string;
+    readonly field: string;
+    readonly message: string;
+    readonly blocking: boolean;
+}
+
+/** What a type's rules find in these values — pure, for the editor as for the gate. */
+export declare const qualityFindings: (type: Pick<ContentType, "quality">, values: Readonly<Record<string, unknown>>) => ReadonlyArray<QualityFinding>;
+
+/** One quality check of a type — see `ContentTypeSpec.quality`. */
+export 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;
+}
+
+/** Effect form of {@link qualityViolations}. */
+export declare const qualityViolations: (...args: Parameters<typeof qualityViolations_2>) => Effect<readonly FieldViolation[], never, never>;
+
+/**
+ * The publish gate: blocking findings in `values` without an approved,
+ * unexpired exception, as violations (`rule: quality.<id>`). Empty for a type
+ * without rules — no read at all.
+ */
+declare const qualityViolations_2: (store: DataStore, type: ContentType, variantId: string, scope: CmsScope, values: Readonly<Record<string, unknown>>, now?: Date) => Promise<ReadonlyArray<FieldViolation>>;
+
+/**
+ * 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;
+}>;
+
+/** Effect form of {@link readChanges}. */
+export declare const readChanges: (...args: Parameters<typeof readChanges_2>) => Effect<{
+    readonly items: ReadonlyArray<ChangeEntry>;
+    readonly next: string | null;
+}, never, never>;
+
+/**
+ * The changes in a site and environment after `after`, oldest first. Keep
+ * `next` and pass it as `after` next time; it stays put when nothing new has
+ * settled, so polling with it never skips.
+ */
+declare const readChanges_2: (store: DataStore, place: Pick<CmsScope, "site" | "environment">, options?: ReadChangesOptions) => Promise<{
+    readonly items: ReadonlyArray<ChangeEntry>;
+    readonly next: string | null;
+}>;
+
+export declare interface ReadChangesOptions {
+    /** The `next` of the previous read; omit to start at the beginning. */
+    readonly after?: string;
+    /** At most this many (default 100). */
+    readonly limit?: number;
+    /** Leave out changes younger than this (default 2000 ms) — see the file header. */
+    readonly settleMs?: number;
+    /** Equality filters, e.g. the tenant for a reader that carries none. */
+    readonly filter?: Readonly<Record<string, unknown>>;
+    readonly now?: number;
+}
+
+/** Effect form of {@link readDraftTexts}. */
+export declare const readDraftTexts: (...args: Parameters<typeof readDraftTexts_2>) => Effect<readonly Readonly<Record<string, unknown>>[], ContentNotFound, never>;
+
+/** The text rows of a draft, whatever revision they belong to. */
+declare const readDraftTexts_2: (store: DataStore, draftId: string) => Promise<ReadonlyArray<Row>>;
+
+/** 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;
+
+/** Effect form of {@link rebaseDraftTexts}. */
+export declare const rebaseDraftTexts: (...args: Parameters<typeof rebaseDraftTexts_2>) => Effect<void, ContentNotFound, never>;
+
+/** After a save: the texts belong to the new revision. In the caller's transaction. */
+declare const rebaseDraftTexts_2: (tx: DataStore, rows: ReadonlyArray<Row>, revisionId: string) => Promise<void>;
+
+/** Effect form of {@link rebuildSearch}. */
+export declare const rebuildSearch: (...args: Parameters<typeof rebuildSearch_2>) => Effect<number, never, never>;
+
+/**
+ * Index every variant of a type again from its derived tables — for content
+ * written before the type declared `search`, or after the search rules
+ * changed. Runs over the store it is handed: a request store rebuilds one
+ * tenant, the root store all of them. Returns how many rows it wrote.
+ */
+declare const rebuildSearch_2: (store: DataStore, type: ContentType) => Promise<number>;
+
+/** Effect form of {@link recertify}. */
+export declare const recertify: (...args: Parameters<typeof recertify_2>) => Effect<Stewardship, never, never>;
+
+/**
+ * Record that `by` checked `revisionId` of the document and it is still
+ * right: the next review is `reviewEveryDays` from `now` (none when the type
+ * declares no cycle).
+ */
+declare const recertify_2: (store: DataStore, type: ContentType, documentId: string, place: Place_2, options: {
+    readonly revisionId: string;
+    readonly by: string;
+    readonly now?: Date;
+}) => Promise<Stewardship>;
+
+/** Effect form of {@link recordAiOperation}. */
+export declare const recordAiOperation: (...args: Parameters<typeof recordAiOperation_2>) => Effect<string, never, never>;
+
+/** Record one call, in the caller's transaction; its id. */
+declare const recordAiOperation_2: (tx: DataStore, input: AiOperationInput) => Promise<string>;
+
+/** Effect form of {@link recordChange}. */
+export declare const recordChange: (...args: Parameters<typeof recordChange_2>) => Effect<void, never, never>;
+
+/** Append one change, in the caller's transaction. A type without `changeFeed` writes nothing. */
+declare const recordChange_2: (tx: DataStore, type: ContentType, row: Row, scope: CmsScope, action: "published" | "unpublished", origin?: ChangeOrigin) => Promise<void>;
+
+/**
+ * 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;
+
+/** Effect form of {@link recordExperimentEvent}. */
+export declare const recordExperimentEvent: (...args: Parameters<typeof recordExperimentEvent_2>) => Effect<boolean, never, never>;
+
+/**
+ * Count a reader once per kind: `exposure` when they were shown the page,
+ * `conversion` when they reached the goal. Only while the experiment runs; a
+ * conversion only after an exposure (a reader who never saw a version cannot
+ * be converted by it). Returns whether this call counted.
+ */
+declare const recordExperimentEvent_2: (store: DataStore, experiment: Experiment, readerId: string, kind: "exposure" | "conversion", now?: Date) => Promise<boolean>;
+
+/** Effect form of {@link recordPaths}. */
+export declare const recordPaths: (...args: Parameters<typeof recordPaths_2>) => Effect<void, never, never>;
+
+/**
+ * Record the paths of a tree type's published documents in `scope` — or, for
+ * a type with an `address` field, each document's address — turning every
+ * changed one into a redirect. Runs after a publish or unpublish, in the
+ * caller's transaction. A type with neither is left alone.
+ */
+declare const recordPaths_2: (tx: DataStore, type: ContentType, scope: CmsScope, tenantId: unknown) => Promise<void>;
+
+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>;
+}
+
+/** Effect form of {@link redirectTarget}. */
+export declare const redirectTarget: (...args: Parameters<typeof redirectTarget_2>) => Effect<string | null, never, never>;
+
+/** The document a former `path` now points at in `scope` (and `tenantId`, when given), or null. */
+declare const redirectTarget_2: (store: DataStore, type: string, path: string, scope: CmsScope, tenantId?: unknown) => Promise<string | null>;
+
+/** 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;
+
+/** A reference found in a variant's values. */
+export declare interface ReferenceOccurrence {
+    readonly path: string;
+    readonly targetType: string;
+    readonly targetDocumentId: string;
+}
+
+/** Every reference the values make, by the content type's declared fields. */
+export declare const referencesOf: (type: ContentType, values: Readonly<Record<string, unknown>>) => ReadonlyArray<ReferenceOccurrence>;
+
+/**
+ * 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"]>;
+    }>>;
+}>;
+
+/** One live use of a document. */
+export declare interface ReferenceUse {
+    readonly sourceType: string;
+    readonly sourceDocumentId: string;
+    readonly sourceVariantId: string;
+    readonly locale: string;
+    readonly path: string;
+}
+
+/** Effect form of {@link regrantExtension}. */
+export declare const regrantExtension: (...args: Parameters<typeof regrantExtension_2>) => Effect<ExtensionChange, never, never>;
+
+/** Grant a revoked extension again — `consent` must cover everything its version asks for. */
+declare const regrantExtension_2: (tx: DataStore, extensionId: string, consent: ReadonlyArray<ExtensionCapability>) => Promise<ExtensionChange>;
+
+/** The lifecycle of a release. */
+export declare const RELEASE_STATUSES: readonly ["draft", "scheduled", "published", "failed"];
+
+/**
+ * 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;
+}>;
+
+export declare type ReleaseStatus = (typeof RELEASE_STATUSES)[number];
+
+/** Effect form of {@link releaseStatusOf}. */
+export declare const releaseStatusOf: (...args: Parameters<typeof releaseStatusOf_2>) => Effect<string | null, never, never>;
+
+/** A release's status (`draft`, `scheduled`, `published`, …), or null when there is none of that id. */
+declare const releaseStatusOf_2: (store: DataStore, releaseId: string) => Promise<string | null>;
+
+/** Effect form of {@link removeGlossaryTerm}. */
+export declare const removeGlossaryTerm: (...args: Parameters<typeof removeGlossaryTerm_2>) => Effect<boolean, never, never>;
+
+/** Remove an entry; false when there was none in this workspace. */
+declare const removeGlossaryTerm_2: (tx: DataStore, tenantId: string, entryId: string) => Promise<boolean>;
+
+/** Effect form of {@link removeRedirect}. */
+export declare const removeRedirect: (...args: Parameters<typeof removeRedirect_2>) => Effect<boolean, never, never>;
+
+/**
+ * Remove the redirect from `fromPath` in `scope`. True when there was one. A
+ * page that had the address and is no longer live still answers it as gone
+ * (`goneAt`). In the caller's transaction.
+ */
+declare const removeRedirect_2: (tx: DataStore, type: ContentType, scope: CmsScope, fromPath: string) => Promise<boolean>;
+
+/**
+ * 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>;
+
+/** Effect form of {@link requestChanges}. */
+export declare const requestChanges: (...args: Parameters<typeof requestChanges_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound | RevisionMismatch | ReviewStepRefused, never>;
+
+/** Send the revision in review back with a note. Same checks as approving, minus self-approval. */
+declare const requestChanges_2: (store: DataStore, type: ContentType, variantId: string, scope: CmsScope, options: Omit<DecideOptions, "allowSelfApproval">) => Promise<Row>;
+
+export declare type RequestExceptionResult = {
+    readonly ok: true;
+    readonly id: string;
+} | {
+    readonly ok: false;
+    readonly reason: 'unknownRule' | 'notBlocking' | 'noReason' | 'badExpiry' | 'alreadyOpen';
+};
+
+/** Effect form of {@link requestQualityException}. */
+export declare const requestQualityException: (...args: Parameters<typeof requestQualityException_2>) => Effect<RequestExceptionResult, ContentNotFound, never>;
+
+/** Ask for an exception to one blocking rule on one variant, until `expiresAt`. */
+declare const requestQualityException_2: (tx: DataStore, type: ContentType, variantId: string, scope: CmsScope, input: {
+    readonly ruleId: string;
+    readonly reason: string;
+    readonly expiresAt: Date;
+    readonly actorId: string;
+}, now?: Date) => Promise<RequestExceptionResult>;
+
+/** Effect form of {@link requestReview}. */
+export declare const requestReview: (...args: Parameters<typeof requestReview_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound, never>;
+
+/** Ask for review of the revision the draft shows now. Use the caller's transaction. */
+declare const requestReview_2: (store: DataStore, type: ContentType, variantId: string, scope: CmsScope, options: {
+    readonly actorId: string;
+    readonly note?: string;
+}) => Promise<Row>;
+
+/** One published entry found by {@link CmsApi.resolve}, with where it came from. */
+export declare interface ResolvedEntry {
+    /** The published row that answers the request. */
+    readonly row: Row;
+    /** The locale of `row`. */
+    readonly locale: string;
+    /** The locale the surface was asked for (its scope's locale). */
+    readonly requestedLocale: string;
+    /** True when `row` is a fallback locale's variant — the requested locale
+     *  has none for this document. Resolved at read time, never stored. */
+    readonly fallback: boolean;
+}
+
+/** What a preview link shows. */
+export declare type ResolvedPreviewShare = {
+    readonly ok: true;
+    readonly share: Row;
+    readonly contentType: string;
+    readonly locale: string;
+    /** The revision shown, and its values. */
+    readonly revisionId: string;
+    readonly revision: number;
+    readonly values: Readonly<Record<string, unknown>>;
+}
+/** `unknown` also answers a token that never existed — no oracle for guessing. */
+| {
+    readonly ok: false;
+    readonly reason: 'unknown' | 'expired' | 'revoked';
+};
+
+/** Effect form of {@link resolveMedia}. */
+export declare const resolveMedia: (...args: Parameters<typeof resolveMedia_2>) => Effect<Record<string, unknown>, never, never>;
+
+/**
+ * Resolve every `media` field on ONE row (including media nested inside
+ * `Array` / `Struct` fields) from its stored storage key to a served URL,
+ * using the caller-supplied `resolve`. Returns a NEW row; the input is not
+ * mutated. A key the resolver returns `null` for is left as-is.
+ *
+ * A content type with no media fields returns the row unchanged (no work).
+ */
+declare const resolveMedia_2: (type: Pick<ContentType, "fields">, row: Readonly<Record<string, unknown>>, resolve: MediaResolver) => Promise<Record<string, unknown>>;
+
+/** Effect form of {@link resolveMediaAll}. */
+export declare const resolveMediaAll: (...args: Parameters<typeof resolveMediaAll_2>) => Effect<readonly Record<string, unknown>[], never, never>;
+
+/** Resolve media across MANY rows in one call (the list-read case). */
+declare const resolveMediaAll_2: (type: Pick<ContentType, "fields">, rows: ReadonlyArray<Readonly<Record<string, unknown>>>, resolve: MediaResolver) => Promise<ReadonlyArray<Record<string, unknown>>>;
+
+/** What {@link CmsApi.resolve} looks up. */
+export declare interface ResolveOptions {
+    /** The column and value that identify the entry, e.g. `{ field: 'slug', value }`. */
+    readonly key: {
+        readonly field: string;
+        readonly value: unknown;
+    };
+    /** Equality filters applied to every lookup (e.g. the site's tenant). */
+    readonly filter?: Readonly<Record<string, unknown>>;
+    /** Locales to try, in order, when the requested one has no match. */
+    readonly fallback?: ReadonlyArray<string>;
+}
+
+/** Effect form of {@link resolvePreviewShare}. */
+export declare const resolvePreviewShare: (...args: Parameters<typeof resolvePreviewShare_2>) => Effect<ResolvedPreviewShare, ContentNotFound | PreviewShareRejected, never>;
+
+/**
+ * Resolve a preview link's token. The only cross-tenant read here: the token
+ * is the authorization, and everything read is confined to the share's own
+ * tenant and variant. A draft that no longer exists answers `unknown`.
+ */
+declare const resolvePreviewShare_2: (store: DataStore, token: string, now?: Date) => Promise<ResolvedPreviewShare>;
+
+/** Effect-native `restoreRevision` (see {@link saveDraftEffect}). */
+export declare const restoreRevision: (store: DataStore, type: ContentType, id: string, scope: CmsScope, revisionId: string) => Effect_2.Effect<Row, ContentValidationFailed | ContentNotFound>;
+
+/** Effect form of {@link retireDuplicate}. */
+export declare const retireDuplicate: (...args: Parameters<typeof retireDuplicate_2>) => Effect<RetireDuplicateResult, ContentNotFound, never>;
+
+/**
+ * Retire `copyId` in favour of `keepId` — both drafts of `type` in `scope`
+ * holding the same file. Archived when no published content references the
+ * copy (`usedBy`); refused with those references otherwise.
+ */
+declare const retireDuplicate_2: (tx: DataStore, type: ContentType, scope: CmsScope, input: {
+    readonly copyId: string;
+    readonly keepId: string;
+    readonly field: string;
+    readonly fingerprint: Fingerprint;
+}) => Promise<RetireDuplicateResult>;
+
+export declare type RetireDuplicateResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: 'notDuplicate';
+} | {
+    readonly ok: false;
+    readonly reason: 'inUse';
+    readonly usedBy: ReadonlyArray<ReferenceUse>;
+};
+
+/** Effect form of {@link retryRelease}. */
+export declare const retryRelease: (...args: Parameters<typeof retryRelease_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound | ReleaseNotEditable | ReviewRequired | ReferenceUnavailable, never>;
+
+/**
+ * Take a failed release back to draft, so it can be published or scheduled
+ * again once its cause is fixed (an approval given, a blocked asset
+ * replaced). Its entries stay as they were; the failure is cleared. Throws
+ * `ReleaseNotEditable` for a release that did not fail.
+ */
+declare const retryRelease_2: (store: DataStore, releaseId: string) => Promise<Row>;
+
+/**
+ * Fire the content type's DECLARED revalidations (`revalidate: { paths,
+ * tags }`). Call it AFTER the publish/unpublish has committed — a web replica
+ * re-rendering on the purge must read the committed state, which is why the
+ * write ops themselves never fire it (they run inside the caller's open
+ * transaction). `publishDue` calls it after each of its commits; a mutation
+ * fires it from a post-commit subscriber on `<type>_published`.
+ * Best-effort by design (the entry also expires by its own TTL): a transport
+ * failure is logged and never reaches the caller.
+ */
+export declare const revalidateContent: (type: ContentType) => void;
+
+export declare const REVIEW_ACTIONS: readonly ["requested", "approved", "changesRequested"];
+
+export declare type ReviewAction = (typeof REVIEW_ACTIONS)[number];
+
+/** Effect form of {@link reviewLog}. */
+export declare const reviewLog: (...args: Parameters<typeof reviewLog_2>) => Effect<readonly Readonly<Record<string, unknown>>[], never, never>;
+
+/** The variant's review steps, newest first. */
+declare const reviewLog_2: (store: DataStore, type: ContentType, variantId: string, scope: CmsScope) => Promise<ReadonlyArray<Row>>;
+
+/**
+ * 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;
+}>;
+
+/** Effect form of {@link reviewRequiredFor}. */
+export declare const reviewRequiredFor: (...args: Parameters<typeof reviewRequiredFor_2>) => Effect<boolean, never, never>;
+
+/**
+ * Whether publishing `type` needs an approval: always, never, or — for a type
+ * left to the workspace — when the workspace of `variantId` requires it.
+ */
+declare const reviewRequiredFor_2: (store: DataStore, type: ContentType, variantId?: string) => Promise<boolean>;
+
+/** `notRequired`: the type declares no review cycle, or the document was never published. */
+export declare type ReviewState = 'notRequired' | 'scheduled' | 'due';
+
+/** Where a variant's review stands. */
+export declare interface ReviewStatus {
+    /** `none` also when the last step concerns a revision the draft no longer shows. */
+    readonly state: 'none' | 'inReview' | 'approved' | 'changesRequested';
+    /** The revision the last step concerns (null without any step). */
+    readonly revisionId: string | null;
+    /** True when the draft moved on since the last step. */
+    readonly stale: boolean;
+    readonly lastStep: Row | null;
+}
+
+/** Effect form of {@link reviewStatus}. */
+export declare const reviewStatus: (...args: Parameters<typeof reviewStatus_2>) => Effect<ReviewStatus, ContentNotFound | ReviewStepRefused, never>;
+
+declare const reviewStatus_2: (store: DataStore, type: ContentType, variantId: string, scope: CmsScope) => Promise<ReviewStatus>;
+
+/**
+ * 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", "ambiguousOrder"]>;
+}>;
+
+/**
+ * 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;
+}>;
+
+/** Effect form of {@link revokeExtension}. */
+export declare const revokeExtension: (...args: Parameters<typeof revokeExtension_2>) => Effect<ExtensionChange, never, never>;
+
+/** Take every capability away; the install and its data stay. */
+declare const revokeExtension_2: (tx: DataStore, extensionId: string) => Promise<ExtensionChange>;
+
+/** Effect form of {@link revokePreviewShare}. */
+export declare const revokePreviewShare: (...args: Parameters<typeof revokePreviewShare_2>) => Effect<void, ContentNotFound | PreviewShareRejected, never>;
+
+/** Revoke one of the caller's shares; the link stops working at once. */
+declare const revokePreviewShare_2: (store: DataStore, shareId: string, now?: Date) => Promise<void>;
+
+/** 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>;
 
-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;
+/** 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 verified preview claim. */
-export declare interface PreviewClaim {
-    readonly type: string;
-    readonly id: string;
+/** 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;
+};
 
-/** Mint a signed preview token for a draft row. */
-export declare const previewToken: (type: string, id: string, options?: {
-    ttlSeconds?: number;
-    secret?: string;
-}) => string;
+/** An inline mark. */
+export declare type RichMark = 'bold' | 'italic' | 'underline';
 
 /**
- * Publish a draft: copy the draft row's declared fields into
- * `<type>_published` (insert on first publish, keyed update after — the
- * published row keeps the SAME id) and mark the draft `status:
- * 'published'`. Runs inside `store.transactional`, so the copy + the
- * draft status flip land atomically per row. Both tables are
- * reactive, so the publish wakes live consumer subscriptions.
- *
- * A missing draft id — including another tenant's draft, which a scoped
- * store reads as absent — throws `ContentNotFound`.
- *
- * Returns the published row.
+ * 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 const publish: (store: DataStore, type: ContentType, id: string) => Promise<Row>;
+export declare interface RichTextOptions {
+    readonly images?: string;
+    readonly links?: string;
+}
 
-/**
- * Publish every draft of `type` whose scheduled `publishAt` has passed
- * (and that is still a draft). Returns the ids that were published. A
- * driver calls this on an interval from a `*.cron.tsx` schedule (see the
- * README/docs recipe) — it is idempotent: `publish` flips the draft
- * `status` to `'published'`, so a row is never double-published, and
- * `publishAt` is cleared so a later re-save doesn't spuriously re-fire.
- *
- * Runs over the store it is handed: a request-scoped store publishes one
- * tenant's due drafts; a background/root store sweeps every tenant.
- */
-export declare const publishDue: (store: DataStore, type: ContentType, now?: Date) => Promise<ReadonlyArray<string>>;
+export declare const RichTextSurface: (props: RichTextSurfaceProps) => ReactNode;
 
-/** Effect-native `publishDue` — the sweep never fails typed (a store/db error
- *  is a defect), so it carries `never` on the error channel. */
-export declare const publishDueEffect: (store: DataStore, type: ContentType, now?: Date) => Effect.Effect<ReadonlyArray<string>, never>;
+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;
+    };
+}
 
-/** Effect-native `publish` (see {@link saveDraftEffect}). */
-export declare const publishEffect: (store: DataStore, type: ContentType, id: string) => Effect.Effect<Row, ContentNotFound>;
+/** Effect form of {@link rollbackExtension}. */
+export declare const rollbackExtension: (...args: Parameters<typeof rollbackExtension_2>) => Effect<ExtensionChange, never, never>;
 
 /**
- * Resolve every `media` field on ONE row (including media nested inside
- * `Array` / `Struct` fields) from its stored storage key to a served URL,
- * using the caller-supplied `resolve`. Returns a NEW row; the input is not
- * mutated. A key the resolver returns `null` for is left as-is.
- *
- * A content type with no media fields returns the row unchanged (no work).
+ * Back to the version that ran before the last move, with the grant it had
+ * then — one step; a waiting version is dropped. A rollback never widens the
+ * grant beyond what was consented to for that version.
  */
-export declare const resolveMedia: (type: Pick<ContentType, "fields">, row: Readonly<Record<string, unknown>>, resolve: MediaResolver) => Promise<Record<string, unknown>>;
+declare const rollbackExtension_2: (tx: DataStore, extensionId: string) => Promise<ExtensionChange>;
 
-/** Resolve media across MANY rows in one call (the list-read case). */
-export declare const resolveMediaAll: (type: Pick<ContentType, "fields">, rows: ReadonlyArray<Readonly<Record<string, unknown>>>, resolve: MediaResolver) => Promise<ReadonlyArray<Record<string, unknown>>>;
+/** Effect form of {@link rollbackRelease}. */
+export declare const rollbackRelease: (...args: Parameters<typeof rollbackRelease_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound | ReleaseNotEditable | ReviewRequired | ReferenceUnavailable, never>;
 
 /**
- * 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.
+ * Roll a published release back: a NEW release that puts back what each of
+ * its variants showed before it (unpublishing the ones that were not live),
+ * published in the caller's transaction. The rolled-back release is left as it
+ * was. Returns the new release.
  */
-export declare interface RichTextOptions {
-    readonly allowImages?: boolean;
-    readonly allowEmbeds?: boolean;
+declare const rollbackRelease_2: (tx: DataStore, types: ReadonlyArray<ContentType>, releaseId: string, now?: Date) => Promise<Row>;
+
+/** A path found by {@link CmsApi.route}. */
+export declare interface RouteMatch {
+    /** The node for the path's document, in the requested locale's tree. Its
+     *  `path` is the canonical address — it differs from the path asked for
+     *  when that was a fallback locale's path of a translated page, or a
+     *  former address of a page that moved (redirect to `node.path`). */
+    readonly node: TreeNode;
+    /** The tree the node belongs to — for navigation and link resolution. */
+    readonly tree: CmsTree;
+    /** How the path was found: the page's own address, another locale's
+     *  address of it, or an address it had before it moved (answer that one
+     *  with a permanent redirect). */
+    readonly via: 'path' | 'fallback' | 'redirect';
 }
 
+/** Effect form of {@link runBulk}. */
+export declare const runBulk: (...args: Parameters<typeof runBulk_2>) => Effect<readonly BulkResult[], ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch | ReviewRequired | ReferenceUnavailable, never>;
+
 /**
- * Save a row into `<type>_drafts`: apply the `derivedFrom` derivations
- * (caller-provided values for derived fields are overwritten), validate
- * the derived row against the field rules (throws
- * `ContentValidationFailed` with per-field violations), then write.
- *
- * Without `row.id` a new draft is inserted (the id scheme generates the
- * TypeID). With `row.id`, the caller's OWN draft is updated in place; an
- * id that exists only outside the caller's tenant scope throws
- * `ContentIdConflict` — it is never updated or overwritten. The row is
- * written with `status: 'draft'`; through a request-scoped `ctx.store`
- * the tenant/audit columns are stamped by the store spine.
- *
- * Returns the written draft row.
+ * Execute a plan: each `ready` item in its own transaction (hand it a store
+ * that is not already inside one), a publish with the revision the plan
+ * pinned. A gate that closed since the dry run fails that item with its
+ * reason; the others still go through.
  */
-export declare const saveDraft: (store: DataStore, type: ContentType, row: Readonly<Record<string, unknown>>) => Promise<Row>;
+declare const runBulk_2: (store: DataStore, types: ReadonlyArray<ContentType>, place: Place, action: BulkAction, plan: ReadonlyArray<PlannedItem>) => Promise<ReadonlyArray<BulkResult>>;
+
+/** Effect form of {@link runningExperiment}. */
+export declare const runningExperiment: (...args: Parameters<typeof runningExperiment_2>) => Effect<Experiment | null, never, never>;
+
+/** The experiment running on a page in this place, or null. */
+declare const runningExperiment_2: (store: DataStore, type: ContentType, scope: CmsScope, documentId: string) => Promise<Experiment | null>;
 
 /** Effect-native `saveDraft` for handlers written in `Effect.gen` — the
  *  typed failures ride the error channel (`Effect.catchTag('ContentValidationFailed', …)`). */
-export declare const saveDraftEffect: (store: DataStore, type: ContentType, row: Readonly<Record<string, unknown>>) => Effect.Effect<Row, ContentValidationFailed | ContentIdConflict>;
+export declare const saveDraft: (store: DataStore, type: ContentType, row: Readonly<Record<string, unknown>>, scope: CmsScope, options?: SaveDraftOptions) => Effect_2.Effect<Row, ContentValidationFailed | ContentIdConflict | ContentNotFound | RevisionMismatch>;
+
+export declare interface SaveDraftOptions {
+    /** The revisionId the editor last saw; a draft that moved on is not overwritten. */
+    readonly expectedRevision?: string;
+    /**
+     * For a translation: the source-language revision it now reflects. Omitted
+     * on an update, the previous revision's basis carries over — fixing a typo
+     * does not claim the translation caught up with its source.
+     */
+    readonly basedOn?: string;
+    /**
+     * The draft is typed in together (draftTexts.ts): its collaborative fields
+     * are taken from the merged texts on the server, not from `row`, and a
+     * draft that moved on since `expectedRevision` only in those fields is no
+     * conflict.
+     */
+    readonly collaborative?: boolean;
+    /**
+     * With `collaborative`: the editor's own states of the shared texts (each an
+     * encoded CRDT update, by text id), merged in before the save reads them — so
+     * an edit still on its way to the server is not left out of the save.
+     */
+    readonly texts?: ReadonlyArray<{
+        readonly id: string;
+        readonly update: Uint8Array;
+    }>;
+}
+
+/** Effect form of {@link schedulePublish}. */
+export declare const schedulePublish: (...args: Parameters<typeof schedulePublish_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound, never>;
 
 /**
  * Mark a draft to publish automatically at `at`. Sets the draft's
  * `publishAt` timestamp WITHOUT publishing now — a later `publishDue`
- * sweep flips it live once `at` has passed. Keys off the caller's own
- * draft (a foreign / missing id throws `ContentNotFound`); the draft's
+ * sweep flips it live once `at` has passed. `null` cancels the schedule. Keys off the caller's own
+ * draft in `scope` (a foreign / missing id throws `ContentNotFound`); the draft's
  * `status` stays `'draft'` until it goes live.
  *
  * Returns the updated draft row.
  */
-export declare const schedulePublish: (store: DataStore, type: ContentType, id: string, at: Date) => Promise<Row>;
+declare const schedulePublish_2: (store: DataStore, type: ContentType, id: string, at: Date | null, scope: CmsScope) => Promise<Row>;
+
+/** Effect form of {@link scheduleRelease}. */
+export declare const scheduleRelease: (...args: Parameters<typeof scheduleRelease_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound | ReleaseNotEditable | ReviewRequired | ReferenceUnavailable, never>;
+
+/** Plan a draft release for `at`; `publishDueReleases` takes it live. */
+declare const scheduleRelease_2: (store: DataStore, releaseId: string, at: Date) => Promise<Row>;
+
+/** Effect form of {@link scheduleSeries}. */
+export declare const scheduleSeries: (...args: Parameters<typeof scheduleSeries_2>) => Effect<PublishSeries, ContentValidationFailed | ContentNotFound, never>;
+
+/**
+ * Give a draft a repeating live window, replacing any series it had, and arm
+ * its first occurrence that has not ended yet. `ContentValidationFailed`
+ * (field `repeat`) for a rule with problems or with no occurrence left;
+ * `ContentNotFound` for a draft the caller cannot see in `scope`. In the
+ * caller's transaction.
+ */
+declare const scheduleSeries_2: (tx: DataStore, type: ContentType, draftId: string, scope: CmsScope, rule: RecurrenceRule, now?: Date) => Promise<PublishSeries>;
 
-/** Effect-native `schedulePublish` — the `ContentNotFound` failure rides the
- *  error channel (`Effect.catchTag('ContentNotFound', …)`). */
-export declare const schedulePublishEffect: (store: DataStore, type: ContentType, id: string, at: Date) => Effect.Effect<Row, ContentNotFound>;
+/** Effect form of {@link scheduleUnpublish}. */
+export declare const scheduleUnpublish: (...args: Parameters<typeof scheduleUnpublish_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound, never>;
+
+/**
+ * Mark an entry to be taken down automatically at `at` — the end of a
+ * campaign, an offer that expires. Stamps the draft's `unpublishAt`; a later
+ * `unpublishDue` sweep unpublishes it once `at` has passed, if it is live
+ * then. It may be set before the entry is live (publish at nine, take down at
+ * five). `null` cancels it. A foreign / missing id throws `ContentNotFound`.
+ */
+declare const scheduleUnpublish_2: (store: DataStore, type: ContentType, id: string, at: Date | null, scope: CmsScope) => Promise<Row>;
 
 /**
  * The CMS field namespace. Scalars mirror the effect/Schema names the
@@ -505,7 +3388,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. */
@@ -518,10 +3404,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;
     /**
@@ -538,11 +3426,492 @@ 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;
+};
+
+/** What makes a type findable. */
+export declare interface SearchConfig {
+    /** The string field ranked first — usually the title. */
+    readonly title: string;
+}
+
+/** Effect form of {@link searchContent}. */
+export declare const searchContent: (...args: Parameters<typeof searchContent_2>) => Effect<readonly SearchHit[], never, never>;
+
+/**
+ * Find documents in a site and environment by the words of `query`, best
+ * first; a hit in the title outranks one in the body. Every word must match,
+ * as a word beginning — `tomato` finds `tomatoes` — on postgres, mysql,
+ * sqlite and the in-memory store (mssql: the whole query as a substring).
+ * An empty query finds nothing.
+ */
+declare const searchContent_2: (store: DataStore, place: Pick<CmsScope, "site" | "environment">, query: string, options: SearchOptions) => Promise<ReadonlyArray<SearchHit>>;
+
+export declare interface SearchHit {
+    readonly contentType: string;
+    readonly documentId: string;
+    readonly variantId: string;
+    readonly locale: string;
+    readonly title: string;
+    readonly snippet: SearchSnippet;
+    /** Higher is more relevant; only comparable within one result. */
+    readonly rank: number;
+}
+
+export declare interface SearchOptions {
+    /** `published` for readers, `draft` for editors (every document, in its newest state). */
+    readonly stage: 'draft' | 'published';
+    /** Only this language's variants. */
+    readonly locale?: string;
+    /** Only these content types. */
+    readonly types?: ReadonlyArray<string>;
+    /** At most this many hits (default 20, at most 100). */
+    readonly limit?: number;
+    /** Equality filters, e.g. the tenant for a reader that carries none. */
+    readonly filter?: Readonly<Record<string, unknown>>;
+}
+
+/** A passage of the body around the first hit, and where the hits are in it. */
+export declare interface SearchSnippet {
+    readonly text: string;
+    /** `[start, end)` offsets into `text` of each word that matched. */
+    readonly marks: ReadonlyArray<readonly [number, number]>;
+}
+
+/** The title and body a row is found by: the title field, and the text of every other field that is not derived. */
+export declare const searchTextOf: (type: ContentType, values: Readonly<Record<string, unknown>>) => {
+    readonly title: string;
+    readonly body: string;
+};
+
+export declare type SecretBinding = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: 'notInstalled' | 'notAsked';
+};
+
+/** Effect form of {@link seriesOf}. */
+export declare const seriesOf: (...args: Parameters<typeof seriesOf_2>) => Effect<PublishSeries | null, ContentValidationFailed | ContentNotFound, never>;
+
+/** The series of a draft, or null. */
+declare const seriesOf_2: (store: DataStore, draftId: string) => Promise<PublishSeries | null>;
+
+/** Effect form of {@link setAiBudget}. */
+export declare const setAiBudget: (...args: Parameters<typeof setAiBudget_2>) => Effect<void, never, never>;
+
+/** Set the workspace's monthly token budget; null: no limit. */
+declare const setAiBudget_2: (tx: DataStore, tenantId: string, monthlyTokens: number | null) => Promise<void>;
+
+/** Effect form of {@link setAiSettings}. */
+export declare const setAiSettings: (...args: Parameters<typeof setAiSettings_2>) => Effect<void, never, never>;
+
+/**
+ * Set the workspace's provider and model, and its own key: a string sets it,
+ * `null` removes it (back to the deployment's), `undefined` keeps it.
+ * `settings: null` goes back to the deployment's provider (a budget stays).
+ */
+declare const setAiSettings_2: (tx: DataStore, tenantId: string, settings: {
+    readonly provider: string;
+    readonly model: string;
+    readonly apiKey?: string | null;
+} | null) => Promise<void>;
+
+/** Effect form of {@link setExtensionSettings}. */
+export declare const setExtensionSettings: (...args: Parameters<typeof setExtensionSettings_2>) => Effect<SettingsChange, never, never>;
+
+/** Set some of an installed extension's settings; every value is checked against its manifest. */
+declare const setExtensionSettings_2: (tx: DataStore, extensionId: string, values: Readonly<Record<string, unknown>>) => Promise<SettingsChange>;
+
+/** Effect form of {@link setGlossaryTerm}. */
+export declare const setGlossaryTerm: (...args: Parameters<typeof setGlossaryTerm_2>) => Effect<"added" | "replaced", never, never>;
+
+/** Set the entry for a term and language, in the caller's transaction; `added` or `replaced`. */
+declare const setGlossaryTerm_2: (tx: DataStore, tenantId: string, input: GlossaryInput) => Promise<"added" | "replaced">;
+
+/** Effect form of {@link setOwner}. */
+export declare const setOwner: (...args: Parameters<typeof setOwner_2>) => Effect<Stewardship, never, never>;
+
+/** Make `owner` (an account id) responsible for the document, or nobody (`null`). */
+declare const setOwner_2: (store: DataStore, type: ContentType, documentId: string, place: Place_2, owner: string | null) => Promise<Stewardship>;
+
+/** Effect form of {@link setReviewRequired}. */
+export declare const setReviewRequired: (...args: Parameters<typeof setReviewRequired_2>) => Effect<readonly string[], never, never>;
+
+/** Turn the workspace's review requirement for `typeName` on or off, in the caller's transaction. */
+declare const setReviewRequired_2: (tx: DataStore, tenantId: string, typeName: string, required: boolean) => Promise<ReadonlyArray<string>>;
+
+export declare type SettingsChange = {
+    readonly ok: true;
+    readonly settings: Readonly<Record<string, ExtensionSettingValue>>;
+} | {
+    readonly ok: false;
+    readonly reason: 'notInstalled';
+} | {
+    readonly ok: false;
+    readonly reason: 'invalid';
+    readonly problems: ReadonlyArray<string>;
 };
 
-/** The canonical slug helper: lowercase, hyphenate, strip non-url chars. */
+/** 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>>;
+
+/** Effect form of {@link settleAiOperation}. */
+export declare const settleAiOperation: (...args: Parameters<typeof settleAiOperation_2>) => Effect<boolean, never, never>;
+
+/** What the person did with a proposal; false when it is not a pending proposal. */
+declare const settleAiOperation_2: (tx: DataStore, operationId: string, outcome: "applied" | "discarded") => Promise<boolean>;
+
+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;
 
+/** The passage of `body` around the first word that starts with a query word. */
+export declare const snippetOf: (body: string, query: string) => SearchSnippet;
+
+/** 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;
+
+/** Effect form of {@link startExperiment}. */
+export declare const startExperiment: (...args: Parameters<typeof startExperiment_2>) => Effect<StartExperimentResult, never, never>;
+
+/** Start an experiment on a live page, in the caller's transaction. */
+declare const startExperiment_2: (tx: DataStore, type: ContentType, scope: CmsScope, input: StartExperimentInput, now?: Date) => Promise<StartExperimentResult>;
+
+export declare interface StartExperimentInput {
+    readonly documentId: string;
+    readonly name: string;
+    /** Percent of readers shown version B (1–99). */
+    readonly share: number;
+    readonly overrides: Readonly<Record<string, string>>;
+    readonly goal: string;
+    /** Required: what B is expected to change, and why (at most 500 characters). */
+    readonly hypothesis: string;
+    /** Optional guardrail, 1–50 percentage points. */
+    readonly guardrailMaxDrop?: number | null;
+}
+
+export declare type StartExperimentResult = {
+    readonly ok: true;
+    readonly id: string;
+} | {
+    readonly ok: false;
+    readonly reason: 'notLive' | 'alreadyRunning' | 'noOverrides' | 'badShare' | 'unknownField' | 'noHypothesis' | 'badGuardrail';
+    readonly fields?: ReadonlyArray<string>;
+};
+
+/** Effect form of {@link startStewardship}. */
+export declare const startStewardship: (...args: Parameters<typeof startStewardship_2>) => Effect<void, never, never>;
+
+/**
+ * On a publish, in the caller's transaction: for a type that declares a
+ * review cycle, the document's first publish in this site and environment
+ * starts it. Later publishes leave the date alone — a review is a decision,
+ * not a side effect of saving. A type without `lifecycle` writes nothing.
+ */
+declare const startStewardship_2: (tx: DataStore, type: ContentType, documentId: string, place: Place_2, tenantId: unknown, now?: Date) => Promise<void>;
+
+export declare interface Stewardship {
+    readonly owner: string | null;
+    readonly reviewDue: Date | null;
+    readonly reviewedAt: Date | null;
+    readonly reviewedBy: string | null;
+    readonly reviewedRevision: string | null;
+    readonly review: ReviewState;
+}
+
+/** Effect form of {@link stewardshipOf}. */
+export declare const stewardshipOf: (...args: Parameters<typeof stewardshipOf_2>) => Effect<Stewardship, never, never>;
+
+/** The document's owner and review state. A document never published has neither. */
+declare const stewardshipOf_2: (store: DataStore, type: ContentType, documentId: string, place: Place_2, now?: Date) => Promise<Stewardship>;
+
+/** Effect form of {@link stopExperiment}. */
+export declare const stopExperiment: (...args: Parameters<typeof stopExperiment_2>) => Effect<boolean, never, never>;
+
+/** Stop a running experiment; its counts stay. False when there is none of that id running. */
+declare const stopExperiment_2: (tx: DataStore, experimentId: string, now?: Date) => Promise<boolean>;
+
+/** 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>;
+
+/** Effect form of {@link teamDefaultRole}. */
+export declare const teamDefaultRole: (...args: Parameters<typeof teamDefaultRole_2>) => Effect<string | null, never, never>;
+
+/** The role a new editor of the workspace gets, or null (the app's own default). */
+declare const teamDefaultRole_2: (store: DataStore, tenantId: string) => Promise<string | null>;
+
+/** Effect form of {@link teamInvitations}. */
+export declare const teamInvitations: (...args: Parameters<typeof teamInvitations_2>) => Effect<readonly {
+    readonly email: string;
+    readonly role: string;
+}[], never, never>;
+
+/** Everyone invited to the workspace, by address. */
+declare const teamInvitations_2: (store: DataStore, tenantId: string) => Promise<ReadonlyArray<{
+    readonly email: string;
+    readonly role: string;
+}>>;
+
+export declare interface TeamPlan {
+    /** `set`: the workspace gets it; `kept`: it has one already; null: the blueprint names none. */
+    readonly defaultRole: {
+        readonly role: string;
+        readonly action: 'set' | 'kept';
+    } | null;
+    readonly members: ReadonlyArray<{
+        readonly email: string;
+        readonly role: string;
+        readonly action: 'invite' | 'present';
+    }>;
+    /** Types that need a review: `require` is new for the workspace, `present` it had already. */
+    readonly reviewRequired: ReadonlyArray<{
+        readonly type: string;
+        readonly action: 'require' | 'present';
+    }>;
+}
+
+/** What is wrong with a blueprint's team; empty when nothing is. */
+export declare const teamProblems: (team: BlueprintTeam) => 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>;
+
+/** The entries whose term `text` (in the source language) contains. */
+export declare const termsIn: (text: string, entries: ReadonlyArray<GlossaryEntry>) => ReadonlyArray<GlossaryEntry>;
+
+/**
+ * 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;
+
+/** Where one language stands against the source. */
+export declare interface TranslationState {
+    readonly locale: string;
+    /**
+     * `missing` — no variant; `upToDate` — based on the source's current
+     * revision; `outdated` — based on an older one (see `changed`);
+     * `unknown` — the variant never said what it was based on.
+     */
+    readonly state: 'missing' | 'upToDate' | 'outdated' | 'unknown';
+    readonly variantId: string | null;
+    /** For `outdated`: the source fields that changed since its basis. */
+    readonly changed: ReadonlyArray<string>;
+}
+
+/** The source's variant and each target language's state. */
+export declare interface TranslationStatus {
+    /** The source variant (null when the document has none in the source language). */
+    readonly source: {
+        readonly variantId: string;
+        readonly revisionId: string;
+    } | null;
+    readonly targets: ReadonlyArray<TranslationState>;
+}
+
+/** Effect form of {@link translationStatus}. */
+export declare const translationStatus: (...args: Parameters<typeof translationStatus_2>) => Effect<TranslationStatus, never, never>;
+
+/** The translation status of one document; `translationStatuses` for many. */
+declare const translationStatus_2: (store: DataStore, type: ContentType, documentId: string, scope: Pick<CmsScope, "site" | "environment">, sourceLocale: string, targetLocales: ReadonlyArray<string>) => Promise<TranslationStatus>;
+
+/** Effect form of {@link translationStatuses}. */
+export declare const translationStatuses: (...args: Parameters<typeof translationStatuses_2>) => Effect<ReadonlyMap<string, TranslationStatus>, never, never>;
+
+/**
+ * The translation status of each of `documentIds`, read together: three
+ * reads per 500 documents (their variants, those revisions, the revisions
+ * they were based on), not three per document.
+ */
+declare const translationStatuses_2: (store: DataStore, type: ContentType, documentIds: ReadonlyArray<string>, scope: Pick<CmsScope, "site" | "environment">, sourceLocale: string, targetLocales: ReadonlyArray<string>) => Promise<ReadonlyMap<string, TranslationStatus>>;
+
+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;
+}
+
+/** What {@link CmsApi.tree} and {@link CmsApi.route} read. */
+export declare interface TreeOptions {
+    /** Locales to take a document's variant from, in order, when the requested
+     *  locale has none. */
+    readonly fallback?: ReadonlyArray<string>;
+    /** Equality filters applied to every row read (e.g. the site's tenant). */
+    readonly filter?: Readonly<Record<string, unknown>>;
+}
+
+declare type Typed = {
+    readonly name: string;
+    readonly fields: Readonly<Record<string, FieldSchema>>;
+    readonly templates?: TemplatesConfig;
+};
+
+/** Effect form of {@link typeDraftText}. */
+export declare const typeDraftText: (...args: Parameters<typeof typeDraftText_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound, never>;
+
+/**
+ * Merge one editor's edit (an encoded CRDT update) into a text. The merge is
+ * order-independent, so edits that cross on the wire both survive.
+ * `ContentNotFound` for a text the caller cannot see. In the caller's
+ * transaction.
+ */
+declare const typeDraftText_2: (tx: DataStore, textId: string, update: Uint8Array) => Promise<Row>;
+
+/** Effect form of {@link unavailableAmong}. */
+export declare const unavailableAmong: (...args: Parameters<typeof unavailableAmong_2>) => Effect<ReadonlyMap<string, UnavailableReason>, ReferenceUnavailable, never>;
+
+/**
+ * The documents among `documentIds` that may not be used at `now`, with why.
+ * A document without a record (a type without availability, not published
+ * yet) is not listed.
+ */
+declare const unavailableAmong_2: (store: DataStore, documentIds: ReadonlyArray<string>, scope: Pick<CmsScope, "site" | "environment">, now?: Date) => Promise<ReadonlyMap<string, UnavailableReason>>;
+
+/** Why a referenced document may not be used. */
+export declare type UnavailableReason = 'blocked' | 'expired';
+
+/** 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;
+
+/** Effect form of {@link uninstallExtension}. */
+export declare const uninstallExtension: (...args: Parameters<typeof uninstallExtension_2>) => Effect<ExtensionRemoval, never, never>;
+
+/** Remove an extension and its data; the data comes back as the export. */
+declare const uninstallExtension_2: (tx: DataStore, extensionId: string) => Promise<ExtensionRemoval>;
+
 /**
  * Mark a string field unique PER TENANT. The derived `<type>_drafts` +
  * `<type>_published` tables get a real composite `(tenantId, <field>)`
@@ -553,16 +3922,35 @@ 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;
+
+/** Effect-native `unpublish` (see {@link saveDraftEffect}). */
+export declare const unpublish: (store: DataStore, type: ContentType, id: string, scope: CmsScope) => Effect_2.Effect<void, ContentNotFound>;
+
+/** Effect form of {@link unpublishDue}. */
+export declare const unpublishDue: (...args: Parameters<typeof unpublishDue_2>) => Effect<readonly string[], never, never>;
+
 /**
- * Take a published row down: delete it from `<type>_published` and flip
- * the draft (when present) back to `status: 'draft'`. Atomic per row via
- * `store.transactional`. Throws `ContentNotFound` when the id has no
- * published row in the caller's scope.
+ * Take down every entry of `type` whose scheduled `unpublishAt` has passed.
+ * Returns the ids that were unpublished. Each in its own transaction: the
+ * published copy goes (with its references and search entry, as `unpublish`
+ * does) and `unpublishAt` is cleared together. An entry that is not live when
+ * its time comes only has the marker cleared — there is nothing to take down.
+ * Idempotent; hand it a store outside any transaction (a schedule's
+ * `app.store`), which sweeps every tenant, or a request store for one.
  */
-export declare const unpublish: (store: DataStore, type: ContentType, id: string) => Promise<void>;
+declare const unpublishDue_2: (store: DataStore, type: ContentType, now?: Date) => Promise<ReadonlyArray<string>>;
 
-/** Effect-native `unpublish` (see {@link saveDraftEffect}). */
-export declare const unpublishEffect: (store: DataStore, type: ContentType, id: string) => Effect.Effect<void, ContentNotFound>;
+/** Effect form of {@link upgradeExtension}. */
+export declare const upgradeExtension: (...args: Parameters<typeof upgradeExtension_2>) => Effect<ExtensionChange, never, never>;
+
+/**
+ * Move an installed extension to a newer `manifest`. Nothing new asked for:
+ * applied now, and the grant becomes exactly what the new version asks for.
+ * Anything new: it waits (`pending`), the installed version keeps running.
+ */
+declare const upgradeExtension_2: (tx: DataStore, manifest: CmsExtensionManifest) => Promise<ExtensionChange>;
 
 /**
  * Typed accessor for handlers — reads the `cms` slot the app attached to
@@ -574,13 +3962,42 @@ export declare const useCms: (ctx: {
     readonly cms?: unknown;
 }) => CmsApi;
 
+/** Effect form of {@link usedBy}. */
+export declare const usedBy: (...args: Parameters<typeof usedBy_2>) => Effect<readonly ReferenceUse[], never, never>;
+
+/**
+ * Where a document is used by published content, in one site and
+ * environment, across locales. The store's tenant scoping applies: a request
+ * store sees its own tenant's uses only.
+ */
+declare const usedBy_2: (store: DataStore, target: {
+    readonly type: string;
+    readonly documentId: string;
+}, scope: Pick<CmsScope, "site" | "environment">) => Promise<ReadonlyArray<ReferenceUse>>;
+
 /**
  * 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 type Variant = 'A' | 'B';
+
+export declare interface VariantResult {
+    readonly readers: number;
+    readonly conversions: number;
+    /** conversions / readers; 0 without readers. */
+    readonly rate: number;
+}
 
 /**
  * Verify a preview token. Returns the `{ type, id }` claim on success,
@@ -591,6 +4008,34 @@ export declare const verifyPreviewToken: (token: string, options?: {
     secret?: string;
 }) => PreviewClaim | null;
 
+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>;
+}
+
 /** Comparison operators accepted by `.where(field, op, value)`. */
 export declare type WhereOp = '=' | '!=' | '<' | '<=' | '>' | '>=';
 
@@ -601,10 +4046,66 @@ 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;
 }
 
+/** Effect form of {@link withdrawInvitation}. */
+export declare const withdrawInvitation: (...args: Parameters<typeof withdrawInvitation_2>) => Effect<boolean, never, never>;
+
+/** Withdraw the invitation of `email`; false when there was none. */
+declare const withdrawInvitation_2: (tx: DataStore, tenantId: string, email: string) => Promise<boolean>;
+
+/** 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>>;
+}
+
+/** Effect form of {@link workspaceReviewTypes}. */
+export declare const workspaceReviewTypes: (...args: Parameters<typeof workspaceReviewTypes_2>) => Effect<readonly string[], never, never>;
+
+/** The content types whose publishing needs a review in the workspace (those left to it). */
+declare const workspaceReviewTypes_2: (store: DataStore, tenantId: string) => Promise<ReadonlyArray<string>>;
+
+/** Effect form of {@link writeAvailability}. */
+export declare const writeAvailability: (...args: Parameters<typeof writeAvailability_2>) => Effect<void, ReferenceUnavailable, never>;
+
+/** Record the availability a published document of `type` now has. */
+declare const writeAvailability_2: (tx: DataStore, type: ContentType, published: Row, scope: CmsScope) => Promise<void>;
+
+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 { }