@voltro/cms 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,589 @@
+import { DataStore } from '@voltro/database';
+import { Effect } from 'effect';
+import { ReactNode } from 'react';
+import { Row } from '@voltro/database';
+import { Schema as Schema_2 } from 'effect';
+import { TableLike } from '@voltro/database';
+
+/**
+ * Compute every `derivedFrom` field from its source value. Returns a NEW
+ * row — the input is not mutated. A caller-provided value for a derived
+ * field is OVERWRITTEN (derived values are the content type's opinion,
+ * mirroring the column `.computed()` semantics). Derivations run in
+ * 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>;
+
+/**
+ * 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.
+ */
+export declare const archive: (store: DataStore, type: ContentType, id: string) => Promise<void>;
+
+/** Effect-native `archive` (see {@link saveDraftEffect}). */
+export declare const archiveEffect: (store: DataStore, type: ContentType, id: string) => Effect.Effect<void, ContentNotFound>;
+
+/** 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;
+    /**
+     * Resolve a single row honouring a preview token. With a valid token
+     * for `{type, id}`, reads the DRAFT row; otherwise reads the published
+     * row by id. Returns null when nothing matches / the token is invalid.
+     */
+    preview(type: string, id: string, token: string | undefined): Promise<Row | null>;
+}
+
+/**
+ * Build the `ctx.cms` surface over a request-scoped store. Attach the
+ * result to your `AppContext` slot (or read it via `useCms(ctx)`).
+ */
+export declare const cmsContext: (store: DataStore, types: ReadonlyArray<ContentType>, options?: {
+    secret?: string;
+}) => CmsApi;
+
+export declare interface CmsRestOptions {
+    readonly cms: CmsApi;
+    readonly types: ReadonlyArray<ContentType>;
+    /**
+     * API keys allowed to read. A key may be scoped to specific content
+     * types; `'*'` (or omitting `types`) grants all. Reads
+     * `Authorization: Bearer <key>` or `x-api-key: <key>`.
+     */
+    readonly apiKeys: ReadonlyArray<{
+        key: string;
+        types?: ReadonlyArray<string>;
+    }>;
+    /** Default page size when `?limit` is absent. */
+    readonly defaultLimit?: number;
+    /** Maximum page size — `?limit` is clamped to this. */
+    readonly maxLimit?: number;
+}
+
+/** A minimal HTTP request the REST handler reads. */
+export declare interface CmsRestRequest {
+    readonly method: string;
+    /** Path AFTER the mount prefix, e.g. `/v1/cms/blogPost` or `/v1/cms/blogPost/my-slug`. */
+    readonly path: string;
+    readonly headers: Readonly<Record<string, string | undefined>>;
+    readonly query?: Readonly<Record<string, string | undefined>>;
+}
+
+/** The JSON response the handler returns. */
+export declare interface CmsRestResponse {
+    readonly status: number;
+    readonly body: unknown;
+}
+
+/** Everything the write pipeline can fail with on the typed channel. */
+export declare type CmsWriteError = ContentValidationFailed | ContentNotFound | ContentIdConflict;
+
+/** The lifecycle states a content row moves through. */
+export declare const CONTENT_STATUSES: readonly ["draft", "published", "archived"];
+
+/** The pair of tables a content type compiles to. */
+export declare interface ContentEntities {
+    readonly draft: TableLike;
+    readonly published: TableLike;
+}
+
+/**
+ * Auto-generated content form. Renders one labelled widget per field,
+ * driven entirely by each field's `editorHint`. Stateless — the caller
+ * owns `value` + `onChange`.
+ */
+export declare const ContentForm: (props: ContentFormProps) => ReactNode;
+
+export declare interface ContentFormProps {
+    readonly contentType: ContentFormType;
+    readonly value: ContentValue;
+    readonly onChange: (next: ContentValue) => void;
+    /** Override the widget for one or more editor hints (e.g. a TipTap richText). */
+    readonly widgets?: Partial<Record<EditorHint, Widget>>;
+}
+
+/** 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 {
+}
+
+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;
+}>;
+
+/**
+ * Raised by `publish` / `unpublish` / `archive` when the row id doesn't
+ * exist in the caller's scope. On a tenant-scoped request store this is
+ * ALSO the cross-tenant answer: another tenant's row is indistinguishable
+ * from a missing one (the scoped read never sees it).
+ */
+export declare class ContentNotFound extends ContentNotFound_base {
+}
+
+declare const ContentNotFound_base: Schema_2.TaggedErrorClass<ContentNotFound, "ContentNotFound", {
+    readonly _tag: Schema_2.tag<"ContentNotFound">;
+} & {
+    contentType: typeof Schema_2.String;
+    id: typeof Schema_2.String;
+    /** Which lifecycle table the id was looked up in. */
+    stage: Schema_2.Literal<["draft", "published"]>;
+}>;
+
+/** A chainable read over one content type's published rows. */
+export declare interface ContentQuery {
+    where(field: string, op: WhereOp, value: unknown): ContentQuery;
+    orderBy(field: string, dir?: 'asc' | 'desc'): ContentQuery;
+    limit(n: number): ContentQuery;
+    offset(n: number): ContentQuery;
+    /** Resolve all matching rows. */
+    all(): Promise<ReadonlyArray<Row>>;
+    /** Resolve the first matching row, or null. */
+    one(): Promise<Row | null>;
+}
+
+export declare type ContentStatus = (typeof CONTENT_STATUSES)[number];
+
+/** A registered content type. */
+export declare interface ContentType {
+    readonly name: string;
+    readonly displayName: string;
+    readonly pluralName: string;
+    readonly fields: Readonly<Record<string, FieldSchema>>;
+    readonly list?: ListConfig;
+    readonly idPrefix?: string;
+    /** Field names whose value is computed-on-save (derivedFrom). */
+    readonly derivedFields: ReadonlyArray<string>;
+    /** Field names marked unique-per-tenant (composite `(tenantId, field)` UNIQUE). */
+    readonly uniqueFields: ReadonlyArray<string>;
+}
+
+/** The user-authored spec passed to `defineContentType`. */
+export declare interface ContentTypeSpec {
+    readonly name: string;
+    readonly displayName: string;
+    readonly pluralName: string;
+    readonly fields: Readonly<Record<string, FieldSchema | PipeableField>>;
+    readonly list?: ListConfig;
+    /** Override the TypeID prefix for awkward plurals / long names. */
+    readonly idPrefix?: string;
+}
+
+/**
+ * Compile a content type to its `<type>_drafts` + `<type>_published`
+ * tables. Drafts hold in-progress edits; publishing copies a row to the
+ * 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
+ * `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;
+
+/**
+ * Raised by `validateContent` / `saveDraft` when a row violates the
+ * content type's field rules (pattern / maxLength / typed kinds /
+ * literal sets / rich-text content policy). Carries EVERY violation,
+ * per field, so an editor can annotate the whole form in one pass.
+ */
+export declare class ContentValidationFailed extends ContentValidationFailed_base {
+}
+
+declare const ContentValidationFailed_base: Schema_2.TaggedErrorClass<ContentValidationFailed, "ContentValidationFailed", {
+    readonly _tag: Schema_2.tag<"ContentValidationFailed">;
+} & {
+    contentType: typeof Schema_2.String;
+    violations: Schema_2.Array$<Schema_2.Struct<{
+        field: typeof Schema_2.String;
+        rule: typeof Schema_2.String;
+        message: typeof Schema_2.String;
+    }>>;
+}>;
+
+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).
+ *
+ * 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
+ * string); the lifecycle/mixin columns the pipeline owns (`status`,
+ * `tenantId`, audit who/when) are tolerated on input and ignored; any
+ * OTHER undeclared key is an `unknown` violation (usually a typo'd
+ * field name).
+ *
+ * NOTE on ordering: run `applyDerivations` first when validating a row
+ * 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>;
+
+/**
+ * A standalone CMS client for build-time consumption (the blog
+ * template's CMS mode), where there is no request handle. Same surface
+ * as `ctx.cms`; reads the published tables directly.
+ */
+export declare const createCmsClient: (config: {
+    store: DataStore;
+    types: ReadonlyArray<ContentType>;
+    secret?: string;
+}) => CmsApi;
+
+export declare const defineContentType: (spec: ContentTypeSpec) => ContentType;
+
+/**
+ * Mark a field computed-on-save from another field. The transform runs
+ * before the row is written — `saveDraft` applies it (via
+ * `applyDerivations`) ahead of validation, and `publish` copies the
+ * derived value. A caller-provided value is overwritten, mirroring the
+ * column `.computed()` semantics.
+ *
+ * ```ts
+ * slug: Schema.String.pipe(pattern(/^[a-z0-9-]+$/), derivedFrom('title', slugify))
+ * ```
+ */
+export declare const derivedFrom: (source: string, transform: (value: unknown, row: Record<string, unknown>) => unknown) => FieldRefinement;
+
+/** A field marked computed-on-save from another field's value. */
+export declare interface DerivedSpec {
+    readonly source: string;
+    readonly transform: (value: unknown, row: Record<string, unknown>) => unknown;
+}
+
+/** 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';
+
+/** 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';
+
+/** A refinement applied through `.pipe(...)`. */
+export declare type FieldRefinement = (field: FieldSchema) => FieldSchema;
+
+/** A fully-resolved field descriptor stored on a content type. */
+export declare interface FieldSchema {
+    readonly kind: FieldKind;
+    readonly editorHint: EditorHint;
+    /** When true the field is nullable in the DB + optional in the editor. */
+    readonly isOptional: 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>;
+    /**
+     * When true, the field is unique PER TENANT — the derived tables carry a
+     * composite `(tenantId, <field>)` DB UNIQUE constraint (see contentType.ts).
+     * Only meaningful on a `string` field (typically a slug).
+     */
+    readonly unique?: boolean;
+    /** RichText options. */
+    readonly richText?: RichTextOptions;
+    /** Referenced content-type name for `reference` fields. */
+    readonly referenceType?: string;
+    /** Element field for `array` fields. */
+    readonly element?: FieldSchema;
+    /** Nested field map for `struct` fields. */
+    readonly struct?: Readonly<Record<string, FieldSchema>>;
+    /** Computed-on-save derivation (set via `derivedFrom`). */
+    readonly derived?: DerivedSpec;
+}
+
+/** 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]`. */
+    readonly field: string;
+    /** The rule that failed: `required` | `type` | `maxLength` | `pattern` | `literal` | `richText` | `unknown`. */
+    readonly rule: string;
+    readonly message: string;
+}
+
+/**
+ * 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
+ * types or paths, 405 for non-GET, and 200 with the published rows
+ * otherwise.
+ */
+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';
+    };
+}
+
+/** 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>;
+
+/** Constrain a string field to a regex (source form, validated on save). */
+export declare const pattern: (re: RegExp) => FieldRefinement;
+
+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;
+}
+
+/** A verified preview claim. */
+export declare interface PreviewClaim {
+    readonly type: string;
+    readonly id: string;
+}
+
+/** Mint a signed preview token for a draft row. */
+export declare const previewToken: (type: string, id: string, options?: {
+    ttlSeconds?: number;
+    secret?: string;
+}) => string;
+
+/**
+ * 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.
+ */
+export declare const publish: (store: DataStore, type: ContentType, id: string) => Promise<Row>;
+
+/**
+ * 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>>;
+
+/** 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>;
+
+/** Effect-native `publish` (see {@link saveDraftEffect}). */
+export declare const publishEffect: (store: DataStore, type: ContentType, id: string) => Effect.Effect<Row, ContentNotFound>;
+
+/**
+ * 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).
+ */
+export declare const resolveMedia: (type: Pick<ContentType, "fields">, row: Readonly<Record<string, unknown>>, resolve: MediaResolver) => Promise<Record<string, unknown>>;
+
+/** 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>>>;
+
+/**
+ * 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.
+ */
+export declare interface RichTextOptions {
+    readonly allowImages?: boolean;
+    readonly allowEmbeds?: boolean;
+}
+
+/**
+ * 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.
+ */
+export declare const saveDraft: (store: DataStore, type: ContentType, row: Readonly<Record<string, unknown>>) => Promise<Row>;
+
+/** 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>;
+
+/**
+ * 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
+ * `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>;
+
+/** 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>;
+
+/**
+ * The CMS field namespace. Scalars mirror the effect/Schema names the
+ * docs use; the CMS-only constructors (RichText / Media / Reference /
+ * Array / Struct) carry their editor metadata. `optional()` is exposed
+ * as a property accessor on each scalar through the underlying field.
+ */
+export declare const Schema: {
+    /** Single-line text. `.pipe(maxLength(N>120))` switches it to a textarea. */
+    readonly String: PipeableField;
+    /** Numeric input. */
+    readonly Number: PipeableField;
+    /** Toggle. */
+    readonly Boolean: PipeableField;
+    /** Date-only picker. */
+    readonly Date: PipeableField;
+    /** Date + time picker. */
+    readonly DateTime: PipeableField;
+    readonly maxLength: (value: number) => FieldRefinement;
+    readonly pattern: (re: RegExp) => FieldRefinement;
+    readonly unique: () => FieldRefinement;
+    /** 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.
+     */
+    readonly RichText: (options?: RichTextOptions) => PipeableField;
+    /**
+     * A storage object key (e.g. one issued by `@voltro/plugin-storage`),
+     * stored as text. Resolve the key to a served URL after a read with
+     * `resolveMedia(type, row, resolver)` — the app supplies the resolver
+     * (built from its storage layer's `getUrl`/`mintUrl`), so the core
+     * package stays decoupled from any storage plugin.
+     */
+    readonly Media: () => PipeableField;
+    /** A reference to another content type's published rows. */
+    readonly Reference: (type: string) => PipeableField;
+    /** Repeatable field. Stored as a JSON array. */
+    readonly Array: (element: FieldSchema) => PipeableField;
+    /** Nested object. Stored as a JSON document. */
+    readonly Struct: (fields: Readonly<Record<string, FieldSchema>>) => PipeableField;
+};
+
+/** The canonical slug helper: lowercase, hyphenate, strip non-url chars. */
+export declare const slugify: (value: unknown) => string;
+
+/**
+ * Mark a string field unique PER TENANT. The derived `<type>_drafts` +
+ * `<type>_published` tables get a real composite `(tenantId, <field>)`
+ * DB UNIQUE constraint (the tenant() mixin's `tenantId` is NOT NULL, so
+ * no partial/NULL machinery is needed) — the database rejects a second
+ * row with the same slug in the same tenant, not the application. Pair it
+ * with `derivedFrom('title', slugify)` for a per-tenant-unique slug.
+ */
+export declare const unique: () => FieldRefinement;
+
+/**
+ * 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.
+ */
+export declare const unpublish: (store: DataStore, type: ContentType, id: string) => Promise<void>;
+
+/** Effect-native `unpublish` (see {@link saveDraftEffect}). */
+export declare const unpublishEffect: (store: DataStore, type: ContentType, id: string) => Effect.Effect<void, ContentNotFound>;
+
+/**
+ * Typed accessor for handlers — reads the `cms` slot the app attached to
+ * `AppContext`. Throws a clear message when the CMS isn't wired. Mirrors
+ * the `useWebhooks(ctx)` pattern (slot typed `unknown` to avoid a
+ * circular dep with @voltro/runtime).
+ */
+export declare const useCms: (ctx: {
+    readonly cms?: unknown;
+}) => CmsApi;
+
+/**
+ * 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;
+
+/**
+ * Verify a preview token. Returns the `{ type, id }` claim on success,
+ * `null` on any failure (malformed, signature mismatch, expired). Never
+ * throws. Constant-time signature compare.
+ */
+export declare const verifyPreviewToken: (token: string, options?: {
+    secret?: string;
+}) => PreviewClaim | null;
+
+/** Comparison operators accepted by `.where(field, op, value)`. */
+export declare type WhereOp = '=' | '!=' | '<' | '<=' | '>' | '>=';
+
+export declare type Widget = (props: WidgetProps) => ReactNode;
+
+/** Resolve the widget for a field, honouring `widgets` overrides. */
+export declare const widgetFor: (hint: EditorHint, overrides?: Partial<Record<EditorHint, Widget>>) => Widget;
+
+/** Props for a single field widget. */
+export declare interface WidgetProps {
+    readonly name: string;
+    readonly field: FieldSchema;
+    readonly value: unknown;
+    readonly onChange: (value: unknown) => void;
+}
+
+export { }