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;
    /** Declared ISR revalidations fired on publish/unpublish — see
     *  `ContentTypeSpec.revalidate`. */
    readonly revalidate?: ContentTypeSpec['revalidate'];
    /** 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;
    /**
     * 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.
     *
     * You DON'T need this on postgres for the plain publish case: a route
     * declaring `cacheInvalidatesOn: ['<type>_published']` is already dropped
     * by CDC when the published table changes. Declare routes here for the
     * cases CDC can't cover — non-postgres dialects, pattern purges of routes
     * whose loader reads this content indirectly, or tag fanout.
     */
    readonly revalidate?: {
        /** Route patterns (`/blog/[slug]`) or concrete paths (`/pricing`). */
        readonly paths?: ReadonlyArray<string>;
        /** Tags matched against routes' `cacheInvalidatesOn` entries. */
        readonly tags?: ReadonlyArray<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 { }