import { z } from 'zod';
import { type EmbedSizing } from '../content/embeds.js';
import type { FieldRow, FieldType } from '../db/schema.js';
/**
 * Field types a repeater row may contain.
 *
 * Everything that describes *a value*, and nothing that composes a page. `block` is excluded
 * because blocks are how a page is assembled and a repeater is how one field holds several of
 * something — nesting the first inside the second confuses two different jobs. `repeater` is
 * excluded because a table of tables is a data model, not a field, and the person reaching for it
 * wants a content type with a relation.
 *
 * Stated as an allowlist so a field type added later is excluded until somebody decides otherwise,
 * rather than silently becoming nestable.
 */
export declare const REPEATER_SUB_FIELD_TYPES: readonly ["text", "richtext", "number", "boolean", "date", "select", "media", "taxonomy", "relation", "link", "embed", "snippet"];
export type RepeaterSubFieldType = (typeof REPEATER_SUB_FIELD_TYPES)[number];
/**
 * One sub-field definition.
 *
 * Shaped like the parts of `FieldRow` that describe a field rather than locate it — no id, no
 * position, no content type. `repeaterRowFields` turns these into rows on demand so the same
 * `FieldControl` and the same validation serve them as serve a top-level field.
 */
export declare const repeaterSubField: z.ZodObject<{
    api_id: z.ZodString;
    label: z.ZodString;
    type: z.ZodEnum<{
        number: "number";
        boolean: "boolean";
        text: "text";
        richtext: "richtext";
        date: "date";
        select: "select";
        media: "media";
        taxonomy: "taxonomy";
        relation: "relation";
        link: "link";
        snippet: "snippet";
        embed: "embed";
    }>;
    required: z.ZodDefault<z.ZodBoolean>;
    help_text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    visible_when: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        field: z.ZodString;
        operator: z.ZodEnum<{
            is_checked: "is_checked";
            is_not_checked: "is_not_checked";
            equals: "equals";
            not_equals: "not_equals";
            is_set: "is_set";
            is_empty: "is_empty";
        }>;
        value: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>>;
}, z.core.$strip>;
export type RepeaterSubField = z.infer<typeof repeaterSubField>;
/**
 * What one link points at.
 *
 * Three kinds rather than one `href`, because the three are stored differently and only one of them
 * is a URL. An item or a file is a **reference** — an id, resolved through the delivery response's
 * `references` and `media` maps exactly as `relation` and `media` fields are — so a page that moves
 * keeps every link aimed at it and nobody edits content to fix a URL. That is the same rule menu
 * items follow, and the reason rich text stores `taproot:item:{id}` instead of a path.
 *
 * Storing the `taproot:` marker here instead was the near miss. It would have made the editor
 * control almost free, since `LinkDialog` already speaks that vocabulary — but it puts a string a
 * consumer has to parse where an id and a lookup belong, and every consumer that forgot would ship
 * `taproot:item:…` to a visitor. Rich text accepts that trade because `set:html` cannot perform a
 * lookup; a structured field has no such excuse.
 */
/**
 * What the *editor* chooses on one placement of a query field.
 *
 * The counterpart to `fieldConfigSchemas.query`: config says what may be asked, this is what was
 * asked. Every key has a default, so a block placed and never touched still resolves — the
 * alternative is a freshly added "Events" block rendering an error until somebody opens it.
 *
 * `termIds` is a list rather than one id for the reason `ItemFilters.termIds` is: an item carrying
 * any of them matches, and a term filter always means the whole branch, which `resolveItemQueries`
 * expands through `termIdsForBranch`. An **empty list means no term filter**, which is the opposite
 * of `ItemFilters`' own convention — deliberately, and the reason is which mistake is recoverable.
 * There, an empty array arrives from a caller that asked for a term with no members and matching
 * everything would silently widen a filter. Here it arrives from an editor who has not picked a
 * term yet, and matching nothing would make a newly placed block render as broken.
 */
declare const queryValueSchema: z.ZodObject<{
    termIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
    sort: z.ZodDefault<z.ZodEnum<{
        path: "path";
        title: "title";
        newest: "newest";
        oldest: "oldest";
        recently_updated: "recently_updated";
        field_asc: "field_asc";
        field_desc: "field_desc";
    }>>;
    limit: z.ZodDefault<z.ZodNumber>;
    dateFilter: z.ZodDefault<z.ZodEnum<{
        any: "any";
        upcoming: "upcoming";
        past: "past";
    }>>;
}, z.core.$strict>;
export type QueryValue = z.infer<typeof queryValueSchema>;
export declare const LINK_KINDS: readonly ["item", "media", "url"];
export type LinkKind = (typeof LINK_KINDS)[number];
export declare function linkValueSchema(allowedKinds?: LinkKind[]): z.ZodType;
/**
 * One embed's stored value: an address and the frame's accessible name. Never markup.
 *
 * `title` is not decoration. An `<iframe>` is an interactive element and its accessible name is the
 * only thing a screen reader can announce about it (WCAG 4.1.2, 2.4.1) — "iframe" is what an
 * untitled one is announced as, which is why asking for it at authoring time is the same move as
 * upload-in-place asking for alt text. It relaxes under `requireComplete: false` like any other
 * minimum, and the advisory checker reports it afterwards; a half-typed form must not be unsavable.
 *
 * The address is refused unless it is `https:` **and** on the field's allowlist:
 *
 * - `http:` is refused rather than upgraded. A browser blocks an insecure frame inside a secure
 *   page, so storing one produces an embed that is guaranteed never to appear — and silently
 *   rewriting an author's address to a scheme the other end may not serve is a different page.
 * - An **empty allowlist admits nothing**, deliberately unlike `media`'s `accept` and `link`'s
 *   `allowedKinds`, where empty means anything. Those two bound a picker over content this CMS
 *   already holds; this one is the boundary against framing an arbitrary third-party origin, and
 *   the tempting fallthrough is the dangerous one — the same reason an empty `ItemFilters.termIds`
 *   matches nothing. So a field created and never configured embeds nothing at all, and the message
 *   below names the screen that fixes it rather than leaving somebody to guess. Defaulting the list
 *   to a few well-known video hosts was the alternative and is not Taproot's opinion to hold: the
 *   config form offers them as one-click presets instead, which reaches the same place without the
 *   CMS asserting which providers a site uses.
 */
export declare function embedValueSchema(allowedHosts?: readonly string[], options?: {
    requireComplete?: boolean;
}): z.ZodType;
export declare const fieldConfigSchemas: {
    readonly text: z.ZodObject<{
        minLength: z.ZodOptional<z.ZodNumber>;
        maxLength: z.ZodOptional<z.ZodNumber>;
        multiline: z.ZodDefault<z.ZodBoolean>;
        placeholder: z.ZodOptional<z.ZodString>;
        pattern: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
    readonly richtext: z.ZodObject<{
        allowedFormats: z.ZodOptional<z.ZodArray<z.ZodString>>;
        maxLength: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>;
    readonly number: z.ZodObject<{
        min: z.ZodOptional<z.ZodNumber>;
        max: z.ZodOptional<z.ZodNumber>;
        integer: z.ZodDefault<z.ZodBoolean>;
        step: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>;
    readonly boolean: z.ZodObject<{
        defaultValue: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>;
    readonly date: z.ZodObject<{
        includeTime: z.ZodDefault<z.ZodBoolean>;
        min: z.ZodOptional<z.ZodString>;
        max: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
    readonly select: z.ZodObject<{
        options: z.ZodArray<z.ZodObject<{
            label: z.ZodString;
            value: z.ZodString;
        }, z.core.$strip>>;
        multiple: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>;
    readonly media: z.ZodObject<{
        multiple: z.ZodDefault<z.ZodBoolean>;
        accept: z.ZodDefault<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>;
    readonly taxonomy: z.ZodObject<{
        taxonomyId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        multiple: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>;
    readonly relation: z.ZodObject<{
        targetContentTypeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        multiple: z.ZodDefault<z.ZodBoolean>;
        reverseLabel: z.ZodOptional<z.ZodString>;
        includeData: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>;
    readonly snippet: z.ZodObject<{
        allowedKinds: z.ZodDefault<z.ZodArray<z.ZodEnum<{
            number: "number";
            text: "text";
            date: "date";
        }>>>;
    }, z.core.$strip>;
    readonly link: z.ZodObject<{
        allowedKinds: z.ZodDefault<z.ZodArray<z.ZodEnum<{
            media: "media";
            item: "item";
            url: "url";
        }>>>;
    }, z.core.$strip>;
    /**
     * What the *admin* fixes about an embed, in the field builder.
     *
     * Both keys belong here rather than on the value, and for the same reason the `query` field splits
     * the same way: an editor pasting a YouTube link should not have to reason about aspect ratios or
     * approved domains. A "Video" field is configured `ratio` once and every editor who uses it gets
     * a 16:9 frame; a "Request information" field is configured `auto` once.
     *
     * The consequence is that one field cannot hold a video on one page and a form on another, and
     * that is the right consequence — those are two block types with two templates and two labels,
     * which is what user-defined types are for. One generic "embed anything" field is the raw-HTML
     * instinct wearing a different hat.
     */
    readonly embed: z.ZodObject<{
        allowedHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
        sizing: z.ZodType<EmbedSizing, unknown, z.core.$ZodTypeInternals<EmbedSizing, unknown>>;
    }, z.core.$strip>;
    readonly block: z.ZodObject<{
        allowedBlocks: z.ZodDefault<z.ZodArray<z.ZodString>>;
        maxBlocks: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>;
    /**
     * What the *admin* fixes about a query, in the field builder.
     *
     * The split between this and the stored value is the feature. Config bounds what may be asked —
     * which content type, which taxonomy an editor may narrow by, how many results they may ask for —
     * and the block instance holds what *was* asked. That is what lets one "Faculty" block type serve
     * twenty department pages: same field definition, each page's editor picks their own term.
     *
     * Fixing the whole query here instead would mean a block type per department, and letting the
     * editor choose everything would mean a picker over every content type on a page where only one
     * makes sense.
     */
    readonly query: z.ZodObject<{
        targetContentTypeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        taxonomyId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        dateFieldApiId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        maxResults: z.ZodDefault<z.ZodNumber>;
        defaultLimit: z.ZodDefault<z.ZodNumber>;
    }, z.core.$strip>;
    readonly repeater: z.ZodObject<{
        minItems: z.ZodDefault<z.ZodNumber>;
        maxItems: z.ZodOptional<z.ZodNumber>;
        fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
            api_id: z.ZodString;
            label: z.ZodString;
            type: z.ZodEnum<{
                number: "number";
                boolean: "boolean";
                text: "text";
                richtext: "richtext";
                date: "date";
                select: "select";
                media: "media";
                taxonomy: "taxonomy";
                relation: "relation";
                link: "link";
                snippet: "snippet";
                embed: "embed";
            }>;
            required: z.ZodDefault<z.ZodBoolean>;
            help_text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            visible_when: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                field: z.ZodString;
                operator: z.ZodEnum<{
                    is_checked: "is_checked";
                    is_not_checked: "is_not_checked";
                    equals: "equals";
                    not_equals: "not_equals";
                    is_set: "is_set";
                    is_empty: "is_empty";
                }>;
                value: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>>;
        }, z.core.$strip>>>;
        sortBy: z.ZodOptional<z.ZodString>;
        sortDirection: z.ZodOptional<z.ZodEnum<{
            asc: "asc";
            desc: "desc";
        }>>;
        summaryTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.core.$strip>;
};
export type FieldConfig<T extends FieldType> = z.infer<(typeof fieldConfigSchemas)[T]>;
export declare const FIELD_TYPES: FieldType[];
/**
 * Field types with no editing control yet.
 *
 * **Empty**, and that is the point of keeping it: every field type the builder offers can now be
 * authored. It was a `availableIn` phase number on every type once, which the picker rendered as a
 * "Phase 1" / "Phase 2" badge — so rich text, media, taxonomy, and blocks announced themselves as
 * forthcoming to a campus editor long after they shipped, and `relation` claimed to be arriving in
 * a phase that had already been declared complete without it.
 *
 * `fieldControls.test.tsx` asserts this list matches what `FieldControl` actually renders, which is
 * what keeps it from drifting again — in either direction. A new field type added without a control
 * fails that test until it is either built or listed here.
 */
export declare const DEFERRED_FIELD_TYPES: FieldType[];
export declare function fieldTypeIsDeferred(type: FieldType): boolean;
export interface FieldTypeMeta {
    type: FieldType;
    label: string;
    description: string;
}
export declare const FIELD_TYPE_META: Record<FieldType, FieldTypeMeta>;
/**
 * Validate and normalise a field's stored config, filling in defaults.
 *
 * Returns the parsed config on success and the issues on failure rather than throwing, so the
 * content-type builder can show errors next to the offending input.
 */
export declare function parseFieldConfig(type: FieldType, raw: unknown): {
    success: true;
    config: Record<string, unknown>;
} | {
    success: false;
    issues: string[];
};
/**
 * Build the Zod schema for a single field's *value*, from that field's stored definition.
 *
 * Optional fields accept `null` and `undefined` rather than only being absent, because an editor
 * clearing an input sends an explicit null.
 */
export declare function buildValueSchema(field: FieldRow, options?: {
    requireComplete?: boolean;
}): z.ZodType;
export interface ItemValidationResult {
    success: boolean;
    /** Parsed values, present only on success. */
    data?: Record<string, unknown>;
    /** Issues keyed by field `api_id`, so the editor can show each next to its input. */
    errors: Record<string, string[]>;
}
/** One block placed into a `block` field. */
export interface BlockInstance {
    /** Stable across saves, so reordering does not remount every editor and lose focus. */
    id: string;
    /** The block type's `api_id`. */
    type: string;
    data: Record<string, unknown>;
    /**
     * A reusable block's id, when this placement is a reference rather than content of its own.
     *
     * Set means the library owns the content: `data` is empty here and filled in at read time by
     * `resolveBlockReferences`. Storing a copy alongside the reference would make "which is
     * authoritative" a question, and the answer would be wrong on whichever page nobody reopened.
     */
    ref?: string;
}
export interface ValidateItemOptions {
    /**
     * Block type schemas keyed by `api_id`, from `blockTypeRegistry`.
     *
     * Omitted, block contents pass through unvalidated — which is right for the content-type
     * builder's preview, where no blocks exist, and wrong for a write. `createItem` and `updateItem`
     * always pass it.
     */
    blockTypes?: Map<string, {
        fields: FieldRow[];
    }>;
    /**
     * How many levels of block nesting remain. Internal — callers leave it unset.
     *
     * A block type may hold a `block` field, so validation recurses. This used to be bounded only by
     * a claim that the editor never offered such a field, which was never true: the field builder
     * renders every field type for a block type just as it does for a content type. That left the
     * real bound at "however deep the request nests", and a hand-written payload nesting thousands
     * of levels would recurse until the stack gave out.
     */
    blockDepth?: number;
    /**
     * Whether "you have not finished" counts as invalid. Defaults to true.
     *
     * There is exactly one caller that passes `false`: `writePreviewDraft`, whose input is a picture
     * of a form somebody is still typing into. A check that refused it would refuse every draft before
     * its last keystroke, which is the whole of what a live preview is for.
     *
     * It relaxes exactly three rules — `required`, a text field's `minLength`, and a repeater's
     * `minItems` — because those are the three that say "this is not finished yet". The distinction
     * worth holding onto: **a minimum is a statement about completeness, a maximum is a bound on what
     * the system will carry.** So `maxLength`, `maxItems`, `maxBlocks`, `allowedBlocks`,
     * `MAX_BLOCK_DEPTH`, select options, number ranges, and date parsing are all untouched.
     *
     * **Sanitising is not one of the three and cannot be.** The richtext transform runs before any
     * refinement and sits outside every `required` branch, so no value reaches a caller unsanitised
     * through this option. That is the property the whole live-preview design rests on, and
     * `fields.test.ts` asserts it at all three walk sites — top level, inside a block, inside a
     * repeater row — along with the write paths still refusing an incomplete item.
     */
    requireComplete?: boolean;
}
/**
 * How deep blocks may nest.
 *
 * Generous enough that no plausible page hits it — a section holding cards holding a rich text is
 * three — and small enough that the recursion cannot exhaust anything. The editor stops offering
 * nested block types before this, by excluding ancestors; this is the boundary's own guarantee,
 * which has to hold for a request the editor never made.
 */
export declare const MAX_BLOCK_DEPTH = 5;
/**
 * Validate a content item's field values against its content type's fields.
 *
 * Unknown keys are dropped rather than rejected: a field removed from the content type should not
 * make every existing item unsavable, and keeping stale keys would let deleted fields resurface.
 */
export declare function validateItemData(fields: FieldRow[], data: unknown, options?: ValidateItemOptions): ItemValidationResult;
/** One row of a repeater. */
export interface RepeaterRow {
    id: string;
    data: Record<string, unknown>;
}
/**
 * Turn sub-field definitions into rows the rest of the system already understands.
 *
 * `FieldControl` renders a `FieldRow` and `validateItemData` validates against them, so
 * synthesising rows here means a repeater's sub-fields get the same controls, the same validation,
 * and the same richtext sanitising as a top-level field — for free, and unable to drift.
 *
 * The ids are derived from the parent's, deterministically. They only have to be unique within one
 * render, and deriving them keeps the DOM ids stable across re-renders where a generated id would
 * remount every input on every keystroke.
 */
export declare function repeaterRowFields(field: FieldRow): FieldRow[];
/**
 * Turn stored field *definitions* into the `FieldRow`s every editor and validator already speaks.
 *
 * Extracted from `repeaterRowFields` when the site settings screen needed the same thing: a set of
 * fields an admin defines, stored as JSON rather than as rows, rendered through `FieldControl` and
 * validated through `validateItemData` like anything else. That is the whole trick — a definition
 * shape already exists (`repeaterSubField`), and synthesising rows from it is what lets a second
 * screen reuse the field system without a second field system.
 *
 * A malformed definition costs that field and not the whole set, which is the tolerance `parseJson`
 * applies everywhere else a stored blob is read back: one bad entry written by hand in a database
 * console must not take a screen down.
 */
export declare function synthesiseFields(definitions: unknown, context: {
    idPrefix: string;
    contentTypeId: string;
    timestamp: string;
}): FieldRow[];
/** Machine names must be safe as both an object key and a URL segment. */
export declare const apiIdSchema: z.ZodString;
export declare const contentTypeInputSchema: z.ZodObject<{
    api_id: z.ZodString;
    name: z.ZodString;
    name_plural: z.ZodString;
    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    kind: z.ZodEnum<{
        page: "page";
        collection: "collection";
        singleton: "singleton";
        block: "block";
    }>;
    icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    url_prefix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    preview_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    item_pages: z.ZodOptional<z.ZodBoolean>;
    hide_from_nav: z.ZodOptional<z.ZodBoolean>;
    no_seo: z.ZodOptional<z.ZodBoolean>;
    no_revisions: z.ZodOptional<z.ZodBoolean>;
    summary_template: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    list_columns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
    list_sort: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
        path: "path";
        title: "title";
        newest: "newest";
        oldest: "oldest";
        recently_updated: "recently_updated";
        field_asc: "field_asc";
        field_desc: "field_desc";
    }>>>;
    list_sort_field: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    default_og_image_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
}, z.core.$strip>;
export declare const fieldInputSchema: z.ZodObject<{
    api_id: z.ZodString;
    label: z.ZodString;
    type: z.ZodEnum<{
        number: "number";
        boolean: "boolean";
        block: "block";
        text: "text";
        richtext: "richtext";
        date: "date";
        select: "select";
        media: "media";
        taxonomy: "taxonomy";
        relation: "relation";
        link: "link";
        snippet: "snippet";
        embed: "embed";
        repeater: "repeater";
        query: "query";
    }>;
    help_text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    required: z.ZodDefault<z.ZodBoolean>;
    localized: z.ZodDefault<z.ZodBoolean>;
    position: z.ZodDefault<z.ZodNumber>;
    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    visible_when: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        field: z.ZodString;
        operator: z.ZodEnum<{
            is_checked: "is_checked";
            is_not_checked: "is_not_checked";
            equals: "equals";
            not_equals: "not_equals";
            is_set: "is_set";
            is_empty: "is_empty";
        }>;
        value: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>>;
}, z.core.$strip>;
export type ContentTypeInput = z.infer<typeof contentTypeInputSchema>;
export type FieldInput = z.infer<typeof fieldInputSchema>;
export {};