@nonext/husk 0.2.3

package/dist/core/index.js

@@ -0,0 +1,12 @@
+export { ENTRY_COLLECTION_GROUP, ERROR_CATEGORIES, FALLBACK_SORT, HUSK_TAG_PREFIX, MAX_ENTRY_INDEXES, MAX_FIELD_COLUMNS, MIGRATION_BATCH_SIZE, MIGRATION_MAX_BATCHES, STATUS_EFFECT, UNTITLED_ENTRY, VALIDATION_RULE_CONTROLS, applyPlan, buildCountQuery, buildListQuery, canSaveEntry, canSearch, checkFieldKey, checkNestedFieldKey, classifyError, confirmationMatches, contentTypeTag, createMigrationRegistry, createRegistryStore, defaultListSort, deleteConfirmationName, deleteConfirmationPhrase, deniedError, draftIssues, entryChangedSince, entrySlugTag, entryTag, entryTags, entryTitle, entryUniqueCheck, errorsUnder, fieldOptionIssues, formFields, formValuesFromEntry, indexCovered, initialFormValues, initialListState, isFilterableField, isHuskTag, isNarrowed, isSearching, listColumns, listFilterQuery, listFilters, mediaTag, mergeIssues, missingEntryIndexes, missingError, moveFieldRow, moveItem, newFieldDefinition, nextSort, normalizeConfirmation, orderedFieldKeys, orderedFields, requiredEntryIndexes, runMigration, sameDefinition, settingsTag, sortableFieldKeys, staleWriteError, statusTransitions, suggestFieldKey, treatmentFor, unroutableIssues, valuesChanged, withFieldOption, withFieldRows, withValidationRule } from '../chunk-6E3ZS5Z5.js';
+export { createCMS } from '../chunk-3I6337WJ.js';
+export { ALLOWED_MEDIA_TYPES, DEFAULT_PAGE_SIZE, FIRESTORE_DOCUMENT_BYTES, INITIAL_SCHEMA_VERSION, MAX_ARRAY_ITEMS, MAX_CONTENT_TYPE_FIELDS, MAX_ENTRY_FIELDS, MAX_FIELD_PURGE, MAX_IMAGE_BYTES, MAX_MEDIA_BYTES, MAX_MEDIA_REFS, MAX_NESTING_DEPTH, MAX_PAGE_SIZE, MAX_SETTINGS_FIELDS, MAX_WRITE_BYTES, MEDIA_ACCEPT_ATTRIBUTE, MEDIA_REFS_KEY, MEDIA_USAGE_LIMIT, MIN_WRITE_INTERVAL_MS, WRITE_BURST_LIMIT, WRITE_BURST_WINDOW_MS, addField, approximateBytes, assertSchemaWritable, buildRegistry, checkMediaFile, checkWritePayload, collectMediaIds, createWriteRateLimiter, fieldKeyState, fieldMapSignature, fileExtension, forgetRemovedField, isSchemaReadOnly, mediaTypeRule, nextSchemaVersion, normalizeLimit, normalizeMediaType, removeField, removedFieldEntries, restoreField, retargetMediaUrls, safeFileName, schemaVersionOf, slugFieldKey, storageShapeChanged, storageSignature, storageSignatureOf, storesTheSameWay } from '../chunk-JAE7HHMM.js';
+export { INITIAL_FIELD_KEY, RESERVED_TYPE_SLUGS, assertTypeSlugAvailable, assertValidContentType, checkTypeSlug, createContentType, defineContentType, newContentType } from '../chunk-ROLKRJWI.js';
+import '../chunk-SOTQ3WP5.js';
+export { assertDeletable, assertListable, assertSingletonCreatable, assertSingletonEntryId, isCollection, isSingleton, singletonEntryId } from '../chunk-R4O7APIX.js';
+import '../chunk-TCFFHTY3.js';
+import '../chunk-NPDBQBLW.js';
+import '../chunk-TS7Y7GEZ.js';
+export { LockedTypeError, PermissionError, SchemaError, SingletonError, ValidationError, WriteLimitError } from '../chunk-4Z6P3XCE.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/entry-D3kiE8T1.d.ts

@@ -0,0 +1,163 @@
+import { c as FieldMap, a as FieldDefinition, f as FieldValues, b as FieldInputValues } from './field-Diyf5siF.js';
+import { d as PermissionMatrix } from './auth-B2gBtHl5.js';
+
+type ContentTypeKind = "collection" | "singleton";
+/**
+ * A field that was removed from a content type while its stored values were kept.
+ *
+ * Removal is a state, not an absence. The definition is parked here instead of being
+ * deleted, so the admin can name the field in a warning, offer it back unchanged, and so a
+ * later purge knows what it is about to destroy. Nothing downstream of the registry reads
+ * this map: forms, validation, list columns and the SDK all read `fields`, which is why a
+ * removed field is inert everywhere without a single consumer having to filter it out.
+ */
+interface RemovedField {
+    /** Exactly the definition the field had at the moment it was removed. */
+    field: FieldDefinition;
+    /** ISO 8601. A plain string, because a stored content type is plain JSON. */
+    removedAt: string;
+    /** uid of whoever removed it. */
+    removedBy: string;
+}
+type RemovedFieldMap = {
+    readonly [key: string]: RemovedField;
+};
+/** Where a content type came from. Code always wins a slug conflict. See the registry. */
+type ContentTypeSource = "code" | "database";
+interface ContentType<TFields extends FieldMap = FieldMap> {
+    slug: string;
+    kind: ContentTypeKind;
+    label: string;
+    /** Plural label for a collection. Defaults to `label` when absent. */
+    labelPlural?: string;
+    description?: string;
+    /** Lucide icon name from the fixed vocabulary in .docs/styleguide/05-icons.md. */
+    icon?: string;
+    fields: TFields;
+    /**
+     * The order the fields are shown in, as a list of field keys.
+     *
+     * It exists because `fields` is a map, and object key order is not a place to store
+     * meaning: it is not a documented Firestore guarantee, Firestore's own ordering of map
+     * values compares keys sorted, and any re-serialization on the way through may change it.
+     * An array has one order and keeps it. A code-defined type never round trips and keeps its
+     * literal's order, so this key is absent there and the object order is used; the Schema
+     * Builder writes it on every save, which is what makes a reorder survive a reload.
+     *
+     * It is a hint, not a second source of truth. An unknown key in it is ignored and a field
+     * missing from it is appended, so a `fieldOrder` that has drifted from `fields` still
+     * renders every field exactly once.
+     */
+    fieldOrder?: readonly string[];
+    /**
+     * Fields removed from `fields` whose stored values are still on the entries. Absent on a
+     * type that has never had a field removed.
+     */
+    removedFields?: RemovedFieldMap;
+    /**
+     * A locked type cannot be edited or deleted through the Schema Builder, and the adapter
+     * rejects schema writes against it even when the UI is bypassed. Only meaningful for a
+     * code-defined type; a database-defined type is never locked.
+     */
+    locked?: boolean;
+    /** Field key shown as the entry's title in lists and pickers. */
+    titleField?: keyof TFields & string;
+    /** Default sort for list views, as a field key with a direction. */
+    defaultSort?: {
+        field: keyof TFields & string;
+        direction: "asc" | "desc";
+    };
+    permissions?: PermissionMatrix;
+    /** Bumped when the stored shape changes. Read by the M10 migration runner. */
+    schemaVersion?: number;
+}
+/**
+ * A content type with its field map erased to `FieldMap`.
+ *
+ * `ContentType<TFields>` is invariant in `TFields`, so a concrete content type produced by
+ * `defineContentType` is not assignable to `ContentType<FieldMap>`. Everything that handles
+ * content types generically (the registry, the adapter, the Schema Builder) takes this
+ * structural shape instead, which a concrete content type does satisfy. Authoring and
+ * inference keep the generic form.
+ */
+interface ContentTypeLike {
+    slug: string;
+    kind: ContentTypeKind;
+    label: string;
+    labelPlural?: string;
+    description?: string;
+    icon?: string;
+    fields: FieldMap;
+    /**
+     * The order the fields are shown in, as a list of field keys.
+     *
+     * It exists because `fields` is a map and a map does not keep an order once it has been
+     * through Firestore: a stored document returns its map keys sorted, not in the order they
+     * were written. A code-defined type never round trips and keeps its literal's order, so
+     * this key is absent there and the object order is used; the Schema Builder writes it on
+     * every save, which is what makes a reorder survive a reload.
+     *
+     * It is a hint, not a second source of truth. An unknown key in it is ignored and a field
+     * missing from it is appended, so a `fieldOrder` that has drifted from `fields` still
+     * renders every field exactly once.
+     */
+    fieldOrder?: readonly string[];
+    removedFields?: RemovedFieldMap;
+    locked?: boolean;
+    titleField?: string;
+    defaultSort?: {
+        field: string;
+        direction: "asc" | "desc";
+    };
+    permissions?: PermissionMatrix;
+    schemaVersion?: number;
+}
+/** Field keys the entry metadata already owns; a content type may not redefine them. */
+declare const RESERVED_FIELD_KEYS: readonly ["id", "status", "createdAt", "createdBy", "updatedAt", "updatedBy", "publishedAt", "schemaVersion"];
+type ReservedFieldKey = (typeof RESERVED_FIELD_KEYS)[number];
+type ContentTypeValues<TType extends {
+    fields: FieldMap;
+}> = FieldValues<TType["fields"]>;
+type ContentTypeInputValues<TType extends {
+    fields: FieldMap;
+}> = FieldInputValues<TType["fields"]>;
+
+declare const ENTRY_STATUSES: readonly ["draft", "published", "archived"];
+type EntryStatus = (typeof ENTRY_STATUSES)[number];
+/**
+ * Everything the adapter owns on an entry. Written on every mutation, never by a form.
+ * Timestamps are ISO 8601 strings at this boundary; the Firestore converter turns them
+ * into Timestamps on the way in and back on the way out.
+ */
+interface EntryMeta {
+    id: string;
+    status: EntryStatus;
+    createdAt: string;
+    createdBy: string;
+    updatedAt: string;
+    updatedBy: string;
+    publishedAt: string | null;
+    schemaVersion: number;
+}
+/** What a read returns: the metadata plus the typed field values. */
+type Entry<TType extends AnyContentTypeShape = AnyContentTypeShape> = EntryMeta & ContentTypeValues<TType>;
+/** What a write accepts: required field values, optional ones omittable, no metadata. */
+type EntryInput<TType extends AnyContentTypeShape = AnyContentTypeShape> = ContentTypeInputValues<TType> & {
+    status?: EntryStatus;
+};
+/**
+ * Structural stand-in for `ContentType<TFields>`. `ContentType` is invariant in its field
+ * map (it uses `keyof TFields` for titleField and defaultSort), so a concrete content type
+ * is not assignable to `ContentType<FieldMap>` and cannot be used as a constraint here.
+ */
+type AnyContentTypeShape = {
+    fields: FieldMap;
+};
+interface FieldError {
+    /** Dotted path, so a repeater reports `blocks.2.title` rather than `blocks`. */
+    path: string;
+    rule: string;
+    message: string;
+}
+
+export { type AnyContentTypeShape as A, type ContentType as C, ENTRY_STATUSES as E, type FieldError as F, RESERVED_FIELD_KEYS as R, type ContentTypeInputValues as a, type ContentTypeKind as b, type ContentTypeLike as c, type ContentTypeSource as d, type ContentTypeValues as e, type Entry as f, type EntryInput as g, type EntryMeta as h, type EntryStatus as i, type RemovedField as j, type RemovedFieldMap as k, type ReservedFieldKey as l };

package/dist/field-Diyf5siF.d.ts

@@ -0,0 +1,158 @@
+/**
+ * A reference from an entry to an item in the media library.
+ *
+ * Entries store the reference, not the media document, so renaming a file or editing its
+ * alt text does not require rewriting every entry that uses it. The denormalized `url` is
+ * a read convenience for the SDK and is refreshed by the adapter when the media item
+ * changes; `mediaId` is the source of truth.
+ */
+interface MediaReference {
+    mediaId: string;
+    url: string;
+}
+interface MediaItem {
+    id: string;
+    name: string;
+    /** MIME type, for example `image/webp`. */
+    type: string;
+    /** Bytes. */
+    size: number;
+    url: string;
+    /** Storage object path, relative to the bucket root. */
+    path: string;
+    alt: string | null;
+    /** Pixels. Null for non-images. */
+    width: number | null;
+    height: number | null;
+    createdAt: string;
+    createdBy: string;
+}
+
+declare const FIELD_TYPES: readonly ["text", "textarea", "number", "boolean", "select", "date", "slug", "richtext", "image", "file", "relation", "repeater"];
+type FieldType = (typeof FIELD_TYPES)[number];
+/**
+ * The full rule vocabulary. Every rule compiles to the same runtime validator, which the
+ * admin form and the adapter both run, so a rule can never be enforced in one place only.
+ */
+interface ValidationRules {
+    required?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    /** Serialized as a string, not a RegExp, because rules travel through Firestore. */
+    pattern?: string;
+    /** Rejects a value already held by another entry of the same content type. */
+    unique?: boolean;
+}
+interface FieldCommon {
+    label: string;
+    description?: string;
+    placeholder?: string;
+    validation?: ValidationRules;
+    /** Hidden fields still store and validate; they are simply not rendered in the form. */
+    hidden?: boolean;
+    readonly?: boolean;
+}
+interface TextField extends FieldCommon {
+    type: "text";
+    defaultValue?: string;
+}
+interface TextareaField extends FieldCommon {
+    type: "textarea";
+    rows?: number;
+    defaultValue?: string;
+}
+interface NumberField extends FieldCommon {
+    type: "number";
+    step?: number;
+    defaultValue?: number;
+}
+interface BooleanField extends FieldCommon {
+    type: "boolean";
+    defaultValue?: boolean;
+}
+interface SelectOption<TValue extends string = string> {
+    value: TValue;
+    label: string;
+}
+interface SelectField<TValue extends string = string> extends FieldCommon {
+    type: "select";
+    options: readonly SelectOption<TValue>[];
+    multiple?: boolean;
+    defaultValue?: TValue;
+}
+interface DateField extends FieldCommon {
+    type: "date";
+    /** `date` stores `YYYY-MM-DD`; `datetime` stores a full ISO 8601 instant. */
+    precision?: "date" | "datetime";
+}
+interface SlugField extends FieldCommon {
+    type: "slug";
+    /** Field key the slug is derived from until the editor overrides it. */
+    from?: string;
+}
+/**
+ * Rich text is stored as a serialized document, not as an HTML string, so the editor choice
+ * (settled in M5) stays an implementation detail and the value can be re-rendered rather
+ * than re-parsed.
+ */
+interface RichTextValue {
+    format: "husk-richtext-v1";
+    content: unknown;
+}
+interface RichtextField extends FieldCommon {
+    type: "richtext";
+    /** Marks and blocks the toolbar offers. Absent means the default set. */
+    features?: readonly string[];
+}
+interface ImageField extends FieldCommon {
+    type: "image";
+    accept?: readonly string[];
+}
+interface FileField extends FieldCommon {
+    type: "file";
+    accept?: readonly string[];
+}
+interface RelationField<TTo extends string = string> extends FieldCommon {
+    type: "relation";
+    /** Slug of the referenced content type. */
+    to: TTo;
+    many?: boolean;
+}
+interface RepeaterField<TFields extends FieldMap = FieldMap> extends FieldCommon {
+    type: "repeater";
+    fields: TFields;
+    min?: number;
+    max?: number;
+}
+type FieldDefinition = TextField | TextareaField | NumberField | BooleanField | SelectField | DateField | SlugField | RichtextField | ImageField | FileField | RelationField | RepeaterField;
+type FieldMap = {
+    readonly [key: string]: FieldDefinition;
+};
+/** The value one field definition produces, before required-ness is applied. */
+type FieldValue<TField extends FieldDefinition> = TField extends TextField | TextareaField | SlugField ? string : TField extends NumberField ? number : TField extends BooleanField ? boolean : TField extends DateField ? string : TField extends SelectField<infer TOption> ? TField extends {
+    multiple: true;
+} ? TOption[] : TOption : TField extends RichtextField ? RichTextValue : TField extends ImageField | FileField ? MediaReference : TField extends RelationField ? TField extends {
+    many: true;
+} ? string[] : string : TField extends RepeaterField<infer TFields> ? FieldValues<TFields>[] : never;
+type IsRequired<TField extends FieldDefinition> = TField extends {
+    validation: {
+        required: true;
+    };
+} ? true : false;
+/**
+ * Read shape: every key is present. An optional field reads as `null` rather than
+ * `undefined`, so a consumer never has to distinguish "absent" from "empty".
+ */
+type FieldValues<TFields extends FieldMap> = {
+    [K in keyof TFields]: IsRequired<TFields[K]> extends true ? FieldValue<TFields[K]> : FieldValue<TFields[K]> | null;
+};
+/** Write shape: optional fields may be omitted entirely. */
+type FieldInputValues<TFields extends FieldMap> = {
+    [K in keyof TFields as IsRequired<TFields[K]> extends true ? K : never]: FieldValue<TFields[K]>;
+} & {
+    [K in keyof TFields as IsRequired<TFields[K]> extends true ? never : K]?: FieldValue<TFields[K]> | null;
+};
+
+export { type BooleanField as B, type DateField as D, FIELD_TYPES as F, type ImageField as I, type MediaItem as M, type NumberField as N, type RelationField as R, type SelectField as S, type TextField as T, type ValidationRules as V, type FieldDefinition as a, type FieldInputValues as b, type FieldMap as c, type FieldType as d, type FieldValue as e, type FieldValues as f, type FileField as g, type MediaReference as h, type RepeaterField as i, type RichTextValue as j, type RichtextField as k, type SelectOption as l, type SlugField as m, type TextareaField as n };

package/dist/field-type-D25Vojb0.d.ts

@@ -0,0 +1,157 @@
+import { ComponentType } from 'react';
+import { F as FieldError, A as AnyContentTypeShape } from './entry-D3kiE8T1.js';
+import { a as FieldDefinition, d as FieldType, c as FieldMap, V as ValidationRules } from './field-Diyf5siF.js';
+
+/** Props every admin field input receives. Field types never read from a store directly. */
+interface FieldInputProps<TValue, TField extends FieldDefinition = FieldDefinition> {
+    /** Dotted path, unique within the form: `title`, `blocks.2.heading`. */
+    path: string;
+    field: TField;
+    value: TValue | null;
+    onChange: (value: TValue | null) => void;
+    onBlur?: (() => void) | undefined;
+    errors: readonly FieldError[];
+    disabled?: boolean | undefined;
+    readonly?: boolean | undefined;
+}
+type FieldInputComponent<TValue, TField extends FieldDefinition = FieldDefinition> = ComponentType<FieldInputProps<TValue, TField>>;
+/** Everything a validator may know without touching the database. */
+interface ValidateCtx {
+    path: string;
+    contentType: AnyContentTypeShape;
+    /** All values of the entry being validated, for cross-field rules. */
+    entry: Record<string, unknown>;
+}
+/**
+ * Recursion, for the two field types that contain other fields.
+ *
+ * `repeater` holds a whole field map, and it cannot convert or name what is inside it
+ * without applying the same field type contract one level down. It must not reach for the
+ * registry itself: the registry imports every spec, so a spec that imports the registry
+ * closes a cycle. The caller that already holds the registry passes the recursion in
+ * instead, and both members below are optional, so a spec that nests nothing ignores them
+ * and a caller that has no registry still gets a working round trip.
+ */
+interface NestedConverter {
+    toStored(fields: FieldMap, values: Record<string, unknown>): Record<string, unknown>;
+    fromStored(fields: FieldMap, data: Record<string, unknown>): Record<string, unknown>;
+}
+/** Names the SDK-facing type of any field definition, one level down. */
+type TsTypeResolver = (field: FieldDefinition) => string;
+/**
+ * Layer 5, as a value or as a function of the field.
+ *
+ * A plain string is the common case and stays exactly as it was. A function is what lets a
+ * field type whose SDK type depends on its own options say so: `select` narrows on
+ * `multiple`, `relation` on `many`, and `repeater` names the object its rows actually
+ * hold. `FieldValue<TField>` in types/field.ts already narrows all three for a code-defined
+ * type; this is what codegen can say for a type created in the Schema Builder, where the
+ * field definition exists only at runtime.
+ */
+type FieldTsType<TField extends FieldDefinition = FieldDefinition> = string | ((field: TField, resolve: TsTypeResolver) => string);
+/**
+ * How one per-type option is edited in the Schema Builder.
+ *
+ * A control, not a field type: `"choice"` is a fixed list of values, `"content-type"` is a
+ * slug picked from the live registry, `"field-key"` is a sibling field of the same level.
+ * The field editor implements this small vocabulary once, and every field type describes
+ * its own options in it, which is what keeps `switch (field.type)` out of the screen.
+ */
+type FieldOptionControl = "text" | "number" | "boolean" | "choice" | "select-options" | "content-type" | "field-key" | "string-list" | "fields";
+interface FieldOptionDescriptor {
+    /** The property this option writes on the field definition. */
+    key: string;
+    label: string;
+    control: FieldOptionControl;
+    help?: string;
+    /** A field of this type is incomplete until the option has a value. */
+    required?: boolean;
+    /** The values a `"choice"` control offers. */
+    choices?: readonly {
+        value: string;
+        label: string;
+    }[];
+}
+/**
+ * Layer 7: what the Schema Builder may configure on this field type, and what it starts as.
+ *
+ * It exists so that the field editor is generated from the registry exactly as every other
+ * admin screen is. Without it, one screen would hold a list of which options belong to
+ * which field type, and a field type added later would render as a bare label until
+ * somebody remembered to edit that list.
+ */
+interface FieldEditorSpec {
+    /** Name shown in the field type picker. */
+    label: string;
+    /** One line, shown under the name in the picker. */
+    description: string;
+    /** The shared validation rules this field type honours. See VALIDATION_RULE_CONTROLS. */
+    rules: readonly (keyof ValidationRules)[];
+    /** The per-type options, in the order the editor shows them. */
+    options: readonly FieldOptionDescriptor[];
+    /**
+     * Everything a new field of this type needs besides `type` and `label`.
+     *
+     * A select with no options and a repeater with no nested fields are both invalid, so a
+     * newly added field cannot start as `{ type, label }` alone.
+     */
+    defaults: Record<string, unknown>;
+}
+/**
+ * The seven-layer contract. A field type is not "added" until every member here is
+ * implemented; a partial field type is a field type that behaves differently in the form
+ * than it does on the server.
+ *
+ *   1. `name`         schema definition: the discriminator a content type writes
+ *   2. `toStored` /
+ *      `fromStored`   stored shape: the round trip through Firestore
+ *   3. `Input`        admin input component
+ *   4. `validate`     validation, run identically by the form and by the adapter
+ *   5. `tsType`       SDK-facing type, used by codegen and by the Developer area
+ *   6. `defaultValue` registration data: what a new entry starts with
+ *   7. `editor`       Schema Builder data: the options, rules and defaults of the type
+ */
+interface FieldTypeSpec<TValue, TField extends FieldDefinition = FieldDefinition> {
+    name: FieldType;
+    toStored(value: TValue | null, field: TField, nested?: NestedConverter): unknown;
+    fromStored(raw: unknown, field: TField, nested?: NestedConverter): TValue | null;
+    Input: FieldInputComponent<TValue, TField>;
+    validate(value: TValue | null, rules: ValidationRules, ctx: ValidateCtx, field: TField): FieldError[];
+    tsType: FieldTsType<TField>;
+    defaultValue(field: TField): TValue | null;
+    editor: FieldEditorSpec;
+}
+/**
+ * A spec whose value and field types have been erased, for storage in the registry.
+ *
+ * The registry is heterogeneous by construction: one spec per field type, each with a
+ * different value type. The erasure stops at this alias; every consumer goes back through
+ * the typed `FieldTypeSpec` for the field it is actually handling.
+ */
+type AnyFieldTypeSpec = FieldTypeSpec<any, any>;
+interface FieldTypeRegistry {
+    get(name: string): AnyFieldTypeSpec | undefined;
+    require(name: string): AnyFieldTypeSpec;
+    has(name: string): boolean;
+    readonly names: readonly FieldType[];
+}
+/**
+ * Builds the single registration point for field types.
+ *
+ * The admin never switches on a field name: it looks the spec up here and renders
+ * `spec.Input`. If a screen needs `switch (field.type)`, the abstraction has failed.
+ */
+declare function registerFieldTypes(specs: readonly AnyFieldTypeSpec[]): FieldTypeRegistry;
+/** What codegen writes for a field whose type nothing has registered. */
+declare const UNKNOWN_TS_TYPE = "unknown";
+/**
+ * Layer 5 for one field definition, resolved through the registry.
+ *
+ * The one place that knows a `tsType` may be a function, so no caller has to branch on it,
+ * and the one place that supplies the recursion a nesting field type asks for. An
+ * unregistered field type resolves to `unknown` rather than throwing: codegen for a
+ * database-defined content type must not fail on one field it does not recognise.
+ */
+declare function resolveTsType(registry: FieldTypeRegistry, field: FieldDefinition): string;
+
+export { type AnyFieldTypeSpec as A, type FieldEditorSpec as F, type NestedConverter as N, type TsTypeResolver as T, UNKNOWN_TS_TYPE as U, type ValidateCtx as V, type FieldInputComponent as a, type FieldInputProps as b, type FieldOptionControl as c, type FieldOptionDescriptor as d, type FieldTsType as e, type FieldTypeRegistry as f, type FieldTypeSpec as g, resolveTsType as h, registerFieldTypes as r };