@riverbankcms/sdk 0.62.4 → 0.67.0

package/dist/_dts/block-form/src/context/FieldPreviewResolverContext.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { FieldConfig } from '../fields/types';
+/**
+ * Context passed to a field preview resolver, providing access to sibling field values.
+ */
+export type FieldPreviewResolverCallContext = {
+    getSiblingValue: (fieldId: string) => unknown;
+};
+/**
+ * Resolve a stored field value to a preview value consumable by UI widgets.
+ *
+ * For repeater thumbnails, resolvers can return media-like objects
+ * (e.g. `{ type: 'image', src: '...' }`) for field types that do not store media directly.
+ */
+export type FieldPreviewResolver = (value: unknown, fieldConfig: FieldConfig, context: FieldPreviewResolverCallContext) => Promise<unknown | null>;
+/**
+ * Map of field type to preview resolver.
+ */
+export type FieldPreviewResolverMap = Partial<Record<FieldConfig['type'], FieldPreviewResolver>>;
+/**
+ * Provides field preview resolvers to descendant components.
+ */
+export declare function FieldPreviewResolverProvider({ resolvers, children, }: {
+    resolvers: FieldPreviewResolverMap;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Access the field preview resolver map.
+ */
+export declare function useFieldPreviewResolvers(): FieldPreviewResolverMap;

package/dist/_dts/block-form/src/context/ImageResolveContext.d.ts

@@ -0,0 +1 @@
+export { ImageResolveContextProvider, useImageResolveContextOptional, } from '@riverbankcms/blocks/client';

package/dist/_dts/block-form/src/context/index.d.ts

@@ -0,0 +1,4 @@
+export { BlockContextProvider, useBlockContext, type BlockContextValue, type BlockContextProviderProps, } from './BlockContext';
+export { DisplayLabelResolverProvider, useDisplayLabelResolvers, type DisplayLabelResolver, type DisplayLabelResolverMap, type ResolverCallContext, } from './DisplayLabelResolverContext';
+export { FieldPreviewResolverProvider, useFieldPreviewResolvers, type FieldPreviewResolver, type FieldPreviewResolverMap, type FieldPreviewResolverCallContext, } from './FieldPreviewResolverContext';
+export { ImageResolveContextProvider, useImageResolveContextOptional, } from './ImageResolveContext';

package/dist/_dts/block-form/src/fields/props.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Widget Props Types
+ *
+ * Runtime props for field widgets - combines field config with runtime context
+ */
+import type { ComponentType, ReactNode } from 'react';
+import type { FormBackend } from '../backend/types';
+import type { FieldConfig } from './types';
+/**
+ * Function for rendering child fields (used by container widgets like GroupField/RepeaterField)
+ */
+export type RenderChildField = (childConfig: FieldConfig, childPath: string) => ReactNode;
+/**
+ * Props for field widget components
+ *
+ * @template TValue - The type of value this field manages
+ * @template TConfig - The specific field config type (e.g., TextFieldConfig, GroupFieldConfig)
+ */
+export interface FieldWidgetProps<TValue = unknown, TConfig extends FieldConfig = FieldConfig> {
+    /** Runtime path to this field (e.g., 'title', 'items.0.name') */
+    path: string;
+    /** Form backend for reading/writing values */
+    backend: FormBackend;
+    /** Field configuration (pure definition) */
+    config: TConfig;
+    /** Function to render child fields (required for container widgets like group/repeater) */
+    renderChild?: RenderChildField;
+}
+/**
+ * Type for field widget components
+ *
+ * Widgets are strongly typed with specific config types (TextFieldConfig, etc.) for
+ * type safety within their implementation. At the registry boundary, type assertions
+ * are used to store them in a homogeneous collection (see registry/widgets.ts).
+ *
+ * This is safe because:
+ * 1. The field.type discriminant ensures the correct widget is selected
+ * 2. Each widget receives its expected config subtype at runtime
+ * 3. The type system prevents accessing properties that don't exist on BaseFieldConfig
+ */
+export type FieldWidgetComponent<TValue = unknown, TConfig extends FieldConfig = FieldConfig> = ComponentType<FieldWidgetProps<TValue, TConfig>>;
+/**
+ * Widget registry - maps field type strings to their components
+ *
+ * This is a heterogeneous collection where each widget has different type parameters,
+ * stored with a common base type for lookup. See registry/widgets.ts for implementation.
+ */
+export type WidgetRegistry = Record<string, FieldWidgetComponent>;

package/dist/_dts/block-form/src/fields/types.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Field Configuration Types
+ *
+ * Pure field definitions independent of how they're created (manifest, manual, etc.)
+ * These types describe what a field IS, not where it came from.
+ *
+ * FieldConfig types are structurally compatible with FieldDefinition from @riverbankcms/blocks,
+ * allowing manifest fields to be passed through with minimal transformation.
+ */
+import type { FieldDefinition } from '@riverbankcms/blocks';
+import type { ZodTypeAny } from 'zod';
+import type { TabGroupFieldConfig } from '../widgets/TabGroupField/types';
+import type { PresetOrCustomFieldConfig } from '../widgets/PresetOrCustomField/types';
+/**
+ * Base configuration for all field types
+ */
+export interface BaseFieldConfig {
+    /** Unique identifier for this field */
+    id: string;
+    /** Field type discriminator */
+    type: string;
+    /** Human-readable label */
+    label: string;
+    /** Optional description/help text */
+    description?: string;
+    /** Whether this field is required (defaults to false if not specified) */
+    required?: boolean;
+    /** Default value for this field */
+    defaultValue?: unknown;
+    /** UI-specific configuration - uses same type as FieldDefinition for compatibility */
+    ui?: FieldDefinition['ui'];
+}
+/**
+ * Text field configuration
+ */
+export interface TextFieldConfig extends BaseFieldConfig {
+    type: 'text';
+    multiline?: boolean;
+    maxLength?: number;
+}
+/**
+ * Number field configuration
+ */
+export interface NumberFieldConfig extends BaseFieldConfig {
+    type: 'number';
+    min?: number;
+    max?: number;
+    step?: number;
+}
+/**
+ * Rich text field configuration
+ */
+export interface RichTextFieldConfig extends BaseFieldConfig {
+    type: 'richText';
+}
+/**
+ * Media field configuration
+ */
+export interface MediaFieldConfig extends BaseFieldConfig {
+    type: 'media';
+    mediaKinds?: ('image' | 'video' | 'audio' | 'document' | 'spreadsheet' | 'archive')[];
+    aspectRatio?: string;
+}
+/**
+ * Boolean field configuration
+ */
+export interface BooleanFieldConfig extends BaseFieldConfig {
+    type: 'boolean';
+}
+/**
+ * Date field configuration
+ */
+export interface DateFieldConfig extends BaseFieldConfig {
+    type: 'date';
+}
+/**
+ * Time field configuration
+ */
+export interface TimeFieldConfig extends BaseFieldConfig {
+    type: 'time';
+}
+/**
+ * DateTime field configuration
+ */
+export interface DateTimeFieldConfig extends BaseFieldConfig {
+    type: 'datetime';
+}
+/**
+ * Slug field configuration
+ */
+export interface SlugFieldConfig extends BaseFieldConfig {
+    type: 'slug';
+    sourceFieldId?: string;
+    statusFieldId?: string;
+    maxLength?: number;
+}
+/**
+ * URL field configuration
+ */
+export interface UrlFieldConfig extends BaseFieldConfig {
+    type: 'url';
+    allowRelative?: boolean;
+}
+/**
+ * Link field configuration
+ */
+export interface LinkFieldConfig extends BaseFieldConfig {
+    type: 'link';
+}
+/**
+ * Select field configuration
+ */
+export interface SelectFieldConfig extends BaseFieldConfig {
+    type: 'select';
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+    multiple?: boolean;
+}
+/**
+ * Reference field configuration
+ */
+export interface ReferenceFieldConfig extends BaseFieldConfig {
+    type: 'reference';
+    referenceKind: string;
+    allowManualEntry?: boolean;
+}
+/**
+ * Group field configuration (nested object)
+ */
+export interface GroupFieldConfig extends BaseFieldConfig {
+    type: 'group';
+    fields: FieldConfig[];
+    /** Optional nested schema shape for compatibility with manifest FieldDefinition */
+    schema?: {
+        fields?: FieldConfig[];
+    };
+}
+/**
+ * Modal field configuration (nested object shown in a dialog)
+ *
+ * Modal fields are structurally similar to group fields, but store children under
+ * `schema.fields` in the block manifest.
+ */
+export interface ModalFieldConfig extends BaseFieldConfig {
+    type: 'modal';
+    schema: {
+        fields: FieldConfig[];
+    };
+}
+/**
+ * Repeater field configuration (array)
+ */
+export type RepeaterFieldConfig = BaseFieldConfig & ({
+    /**
+     * Optional custom validation schema for the entire repeater field.
+     * Useful for complex constraints that aren't expressible via field-level config.
+     */
+    validation?: ZodTypeAny;
+} & ({
+    type: 'repeater';
+    itemLabel?: string;
+    itemLabelSource?: string;
+    minItems?: number;
+    maxItems?: number;
+    polymorphic?: false;
+    fields: FieldConfig[];
+    /** Optional nested schema shape for compatibility with manifest FieldDefinition */
+    schema?: {
+        fields?: FieldConfig[];
+    };
+    itemTypes?: never;
+    allowConversion?: boolean;
+} | {
+    type: 'repeater';
+    itemLabel?: string;
+    itemLabelSource?: string;
+    minItems?: number;
+    maxItems?: number;
+    polymorphic: true;
+    fields?: never;
+    /** Polymorphic repeaters do not use schema.fields */
+    schema?: never;
+    itemTypes: Record<string, {
+        label: string;
+        icon?: string;
+        fields: FieldConfig[];
+    }>;
+    allowConversion?: boolean;
+}));
+/**
+ * Button field configuration
+ */
+export interface ButtonFieldConfig extends BaseFieldConfig {
+    type: 'button';
+    allowedSizes?: Array<'sm' | 'md' | 'lg' | 'xl'>;
+    defaultSize?: 'sm' | 'md' | 'lg' | 'xl';
+}
+/**
+ * Content type select field configuration
+ */
+export interface ContentTypeSelectFieldConfig extends BaseFieldConfig {
+    type: 'contentTypeSelect';
+    /** Filter: all, routable (hasPages=true), nonRoutable (hasPages=false) */
+    filter?: 'all' | 'routable' | 'nonRoutable';
+}
+/**
+ * Entry picker field configuration
+ */
+export interface EntryPickerFieldConfig extends BaseFieldConfig {
+    type: 'entryPicker';
+    /** Fixed content type to filter entries by (no sibling contentType field required) */
+    fixedContentType?: string;
+    /** Field ID that contains the content type to filter entries by */
+    contentTypeField?: string;
+    /** What value should be stored when an entry is selected */
+    valueFrom?: 'id' | 'identifier' | 'slug';
+}
+/**
+ * Union of all field configuration types
+ */
+export type FieldConfig = TextFieldConfig | NumberFieldConfig | RichTextFieldConfig | MediaFieldConfig | BooleanFieldConfig | DateFieldConfig | TimeFieldConfig | DateTimeFieldConfig | SlugFieldConfig | UrlFieldConfig | LinkFieldConfig | SelectFieldConfig | ReferenceFieldConfig | GroupFieldConfig | ModalFieldConfig | RepeaterFieldConfig | ButtonFieldConfig | TabGroupFieldConfig | PresetOrCustomFieldConfig | ContentTypeSelectFieldConfig | EntryPickerFieldConfig;

package/dist/_dts/block-form/src/index.d.ts

@@ -0,0 +1,22 @@
+export * from './client/index';
+export { formatPublishBlockedMessage, formatRecoveryConflictSummary, formatRecoveryConflictTitle, formatUnfinishedBlocksSummary, recoveryConflictCopy, unfinishedBlockCopy, } from './blockDraftSaveability';
+export { WIDGET_NAMES, type WidgetName } from './widgets';
+export { WidgetField, WidgetFieldMessage } from './widgets';
+export type { WidgetFieldProps, WidgetFieldMessageProps } from './widgets';
+export { SelectWidget } from './widgets';
+export type { SelectWidgetProps, SelectWidgetOption } from './widgets';
+export { ToggleWidget } from './widgets';
+export type { ToggleWidgetProps } from './widgets';
+export { TextInputWidget } from './widgets';
+export type { TextInputWidgetProps } from './widgets';
+export { BackgroundColorWidget } from './widgets';
+export type { BackgroundColorWidgetProps, BackgroundColorMode } from './widgets';
+export { BackgroundGradientWidget } from './widgets';
+export type { BackgroundGradientWidgetProps } from './widgets';
+export { BoxStyleWidget } from './widgets';
+export { DatePickerPopover, parseDateValue, type DateParseResult, type DatePickerPopoverProps, } from './widgets';
+export { FieldSettingsModal } from './widgets';
+export type { FieldSettingsModalProps } from './widgets';
+export { SettingsModal } from './widgets';
+export type { SettingsModalProps, SettingsTab, SettingsTabId } from './widgets';
+export * from './utils/fieldHelpers';

package/dist/_dts/block-form/src/manifest/ManifestForm.d.ts

@@ -0,0 +1,37 @@
+/**
+ * ManifestForm - Thin wrapper around FormRenderer for manifest-based forms
+ *
+ * Responsibilities:
+ * 1. Transform manifest FieldDefinitions → FieldConfigs (via adapter)
+ * 2. Pass transformed fields to generic FormRenderer
+ * 3. Handle manifest-specific options (role visibility, etc.)
+ */
+import type { BlockManifest, VisibilityLevel } from '@riverbankcms/blocks';
+import { type FormRendererProps } from '../FormRenderer';
+import type { FormBackend } from '../backend/types';
+export interface ManifestFormProps {
+    manifest: BlockManifest;
+    className?: string;
+    role?: VisibilityLevel;
+    backend: FormBackend;
+    /** Optional widget overrides - allows replacing widgets at runtime */
+    widgetOverrides?: FormRendererProps['widgetOverrides'];
+    /** Optional block kind for SDK field options lookup (e.g., 'block.embed', 'custom.hero') */
+    blockKind?: string;
+    /** Show inline settings trigger for non-content intents (default: true) */
+    showSettingsTrigger?: boolean;
+}
+/**
+ * ManifestForm - Renders form fields from a block manifest
+ *
+ * This is a thin adapter that:
+ * 1. Converts manifest FieldDefinitions to FieldConfigs (via adapter)
+ * 2. Delegates rendering to FormRenderer
+ *
+ * @example
+ * ```tsx
+ * const backend = createRHFBackend(form)
+ * <ManifestForm manifest={blockManifest} backend={backend} />
+ * ```
+ */
+export declare function ManifestForm({ manifest, className, role, backend, widgetOverrides, blockKind, showSettingsTrigger, }: ManifestFormProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/_dts/block-form/src/manifest/canonicalValidation.d.ts

@@ -0,0 +1,5 @@
+import { type NativeInputValidationProps } from '@riverbankcms/blocks/system/manifest/fieldValidation';
+import type { z } from 'zod';
+import type { FieldConfig } from '../fields/types';
+export declare function buildCanonicalFieldSchema(field: FieldConfig): z.ZodTypeAny;
+export declare function getCanonicalNativeInputProps(field: FieldConfig): NativeInputValidationProps;

package/dist/_dts/block-form/src/manifest/filterSdkTabs.d.ts

@@ -0,0 +1,44 @@
+/**
+ * SDK Tab Filtering
+ *
+ * Pure function for filtering tab group tabs based on SDK section options.
+ * This is used by TabGroupField to respect SDK site configuration.
+ */
+import type { SdkSectionOptions } from '../sdk-config';
+/**
+ * Tab definition with optional SDK section option.
+ * This is a minimal interface that matches what TabGroupField receives.
+ */
+export interface FilterableTab {
+    id: string;
+    sdkSectionOption?: 'backgroundColor' | 'backgroundGradient' | 'backgroundImage';
+}
+export declare function isSdkSectionOptionEnabled(sdkSectionOption: FilterableTab['sdkSectionOption'] | undefined, isSdkSite: boolean, sectionOptions: SdkSectionOptions | null): boolean;
+/**
+ * Filters tabs based on SDK section options.
+ *
+ * This pure function handles the filtering logic that was previously embedded
+ * in TabGroupField. It's designed to be testable and reusable.
+ *
+ * ## Filtering Rules
+ *
+ * - If not an SDK site or no sectionOptions exist, all tabs are returned
+ * - Tabs without `sdkSectionOption` are always visible
+ * - Tabs with `sdkSectionOption` are visible unless explicitly disabled
+ * - A disabled option is when `sectionOptions[key] === false`
+ *
+ * @param tabs - Array of tabs to filter
+ * @param isSdkSite - Whether this is an SDK-configured site
+ * @param sectionOptions - SDK section options (may be null)
+ * @returns Filtered array of visible tabs
+ *
+ * @example
+ * ```typescript
+ * const visibleTabs = filterTabsBySdkOptions(
+ *   config.tabs,
+ *   isSdkSite,
+ *   sectionOptions
+ * )
+ * ```
+ */
+export declare function filterTabsBySdkOptions<T extends FilterableTab>(tabs: T[], isSdkSite: boolean, sectionOptions: SdkSectionOptions | null): T[];

package/dist/_dts/block-form/src/manifest/manifestFormAdapter.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Manifest Form Adapter
+ *
+ * Transforms BlockManifest field definitions into FieldConfigs for form rendering.
+ * Handles role-based visibility filtering and structure normalization.
+ *
+ * This adapter is intentionally minimal - it only does what's truly manifest-specific:
+ * 1. Filter fields by role visibility
+ * 2. Flatten nested structure (schema.fields → fields)
+ *
+ * Everything else (validation, defaults, UI) is handled by the generic form system.
+ */
+import type { VisibilityLevel, BlockManifest } from '@riverbankcms/blocks';
+import type { ZodType } from 'zod';
+import type { FieldConfig } from '../fields/types';
+export interface ManifestAdapterOptions {
+    role?: VisibilityLevel;
+}
+export interface ManifestAdapterResult {
+    fields: FieldConfig[];
+    schema: ZodType<Record<string, unknown>, Record<string, unknown>>;
+}
+/**
+ * Union type for manifest form sources
+ * Can be either a BlockManifest or null
+ */
+export type ManifestFormSource = BlockManifest | null;
+/**
+ * Options for manifest validation schema creation
+ */
+export interface ManifestSchemaOptions {
+    role?: VisibilityLevel;
+    widgets?: unknown;
+}
+/**
+ * Result of createManifestValidation
+ */
+export interface ManifestValidationResult {
+    schema: ZodType<Record<string, unknown>, Record<string, unknown>>;
+    fields: FieldConfig[];
+}
+/**
+ * Transform a BlockManifest into form fields and validation schema
+ */
+export declare function createManifestFormAdapter(manifest: BlockManifest, options?: ManifestAdapterOptions): ManifestAdapterResult;
+/**
+ * Create validation schema from a block manifest
+ *
+ * This is a convenience wrapper around createManifestFormAdapter for RHF validation.
+ * Use this when you need a Zod schema for form validation (e.g., with zodResolver).
+ *
+ * @example
+ * ```tsx
+ * const validation = createManifestValidation(manifest, { role: 'author' })
+ * const form = useForm({
+ *   resolver: zodResolver(validation.schema),
+ *   defaultValues: ...
+ * })
+ * ```
+ */
+export declare function createManifestValidation(manifest: BlockManifest, options?: ManifestSchemaOptions): ManifestValidationResult;

package/dist/_dts/block-form/src/manifest/mergeManifestWithSdkOptions.d.ts

@@ -0,0 +1,24 @@
+import type { BlockManifest } from '@riverbankcms/blocks';
+import type { SdkBlockFieldOptionsMap, SdkBlockFieldExtensionsMap } from '../sdk-config/SdkConfigContext';
+/**
+ * Merges SDK-provided field options AND field extensions into a block manifest.
+ *
+ * This creates a single source of truth for validation and rendering:
+ * 1. Field options: Replaces select options for fields with `ui.widget: 'sdkSelect'`
+ * 2. Field extensions: Appends additional fields to the end of the manifest
+ *
+ * Without this merge, the Zod validation schema is built from manifest's
+ * hardcoded options, but SdkSelectField renders SDK options - causing
+ * validation errors when users select SDK-provided values.
+ *
+ * @example
+ * // Field options: Embed block manifest has options [list, grid, carousel]
+ * // SDK config provides options [showcase, list]
+ * // After merge, manifest.fields[layoutField].options = [showcase, list]
+ *
+ * @example
+ * // Field extensions: Body text block has [body] field
+ * // SDK config extends with [layout] field
+ * // After merge, manifest.fields = [body, layout]
+ */
+export declare function mergeManifestWithSdkOptions(manifest: BlockManifest, blockKind: string, sdkBlockFieldOptions?: SdkBlockFieldOptionsMap | null, sdkBlockFieldExtensions?: SdkBlockFieldExtensionsMap | null): BlockManifest;

package/dist/_dts/block-form/src/palette/PaletteContext.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+export type PaletteTokens = Record<string, string>;
+type PaletteContextValue = {
+    tokens: PaletteTokens;
+};
+export declare function PaletteProvider({ tokens, children }: {
+    tokens: PaletteTokens | undefined;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function usePalette(): PaletteContextValue;
+export {};

package/dist/_dts/block-form/src/registry/schemas.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Schema and Default Value Registry
+ * Maps field types to validation schemas and default value builders
+ *
+ * Server-safe - no React, no browser APIs
+ * Can be used in API routes, server components, and validation
+ */
+import { buildTextFieldSchema } from '../widgets/TextField/textFieldSchema';
+import { getTextFieldDefault } from '../widgets/TextField/textFieldDefaults';
+import { buildNumberFieldSchema } from '../widgets/NumberField/numberFieldSchema';
+import { getNumberFieldDefault } from '../widgets/NumberField/numberFieldDefaults';
+import { buildSelectFieldSchema } from '../widgets/SelectField/selectFieldSchema';
+import { getSelectFieldDefault } from '../widgets/SelectField/selectFieldDefaults';
+import { buildBooleanFieldSchema } from '../widgets/BooleanField/booleanFieldSchema';
+import { getBooleanFieldDefault } from '../widgets/BooleanField/booleanFieldDefaults';
+import { buildGroupFieldSchema, type SchemaContext } from '../widgets/GroupField/groupFieldSchema';
+import { getGroupFieldDefault, type DefaultValueContext } from '../widgets/GroupField/groupFieldDefaults';
+import { buildModalFieldSchema } from '../widgets/ModalGroupField/modalFieldSchema';
+import { getModalFieldDefault } from '../widgets/ModalGroupField/modalFieldDefaults';
+import { buildRepeaterFieldSchema } from '../widgets/RepeaterField/repeaterFieldSchema';
+import { getRepeaterFieldDefault } from '../widgets/RepeaterField/repeaterFieldDefaults';
+import { buildUrlFieldSchema } from '../widgets/UrlField/urlFieldSchema';
+import { getUrlFieldDefault } from '../widgets/UrlField/urlFieldDefaults';
+import { buildTimeFieldSchema } from '../widgets/TimeField/timeFieldSchema';
+import { getTimeFieldDefault } from '../widgets/TimeField/timeFieldDefaults';
+import { buildDateFieldSchema } from '../widgets/DateField/dateFieldSchema';
+import { getDateFieldDefault } from '../widgets/DateField/dateFieldDefaults';
+import { buildDateTimeFieldSchema } from '../widgets/DateTimeField/dateTimeFieldSchema';
+import { getDateTimeFieldDefault } from '../widgets/DateTimeField/dateTimeFieldDefaults';
+import { buildSlugFieldSchema } from '../widgets/SlugField/slugFieldSchema';
+import { getSlugFieldDefault } from '../widgets/SlugField/slugFieldDefaults';
+import { buildLinkFieldSchema } from '../widgets/LinkField/linkFieldSchema';
+import { getLinkFieldDefault } from '../widgets/LinkField/linkFieldDefaults';
+import { buildRichTextFieldSchema } from '../widgets/RichTextField/richTextFieldSchema';
+import { getRichTextFieldDefaultValue } from '../widgets/RichTextField/richTextFieldDefaults';
+import { buildMediaFieldSchema } from '../widgets/MediaField/mediaFieldSchema';
+import { getMediaFieldDefaultValue } from '../widgets/MediaField/mediaFieldDefaults';
+import { buildTabGroupFieldSchema, getTabGroupFieldDefault } from '../widgets/TabGroupField/tabGroupFieldSchema';
+import { buildPresetOrCustomFieldSchema } from '../widgets/PresetOrCustomField/presetOrCustomFieldSchema';
+import { getPresetOrCustomFieldDefault } from '../widgets/PresetOrCustomField/presetOrCustomFieldDefaults';
+import { buildReferenceFieldSchema } from '../widgets/ReferenceField/referenceFieldSchema';
+import { getReferenceFieldDefault } from '../widgets/ReferenceField/referenceFieldDefaults';
+import { buildContentTypeSelectFieldSchema } from '../widgets/ContentTypeSelectField/contentTypeSelectFieldSchema';
+import { getContentTypeSelectFieldDefault } from '../widgets/ContentTypeSelectField/contentTypeSelectFieldDefaults';
+import { buildEntryPickerFieldSchema } from '../widgets/EntryPickerField/entryPickerFieldSchema';
+import { getEntryPickerFieldDefault } from '../widgets/EntryPickerField/entryPickerFieldDefaults';
+import type { FieldConfig } from '../fields/types';
+import type { ZodTypeAny } from 'zod';
+export type { SchemaContext, DefaultValueContext };
+export declare const SCHEMA_BUILDERS: {
+    readonly text: typeof buildTextFieldSchema;
+    readonly number: typeof buildNumberFieldSchema;
+    readonly select: typeof buildSelectFieldSchema;
+    readonly boolean: typeof buildBooleanFieldSchema;
+    readonly group: typeof buildGroupFieldSchema;
+    readonly modal: typeof buildModalFieldSchema;
+    readonly repeater: typeof buildRepeaterFieldSchema;
+    readonly url: typeof buildUrlFieldSchema;
+    readonly time: typeof buildTimeFieldSchema;
+    readonly date: typeof buildDateFieldSchema;
+    readonly datetime: typeof buildDateTimeFieldSchema;
+    readonly slug: typeof buildSlugFieldSchema;
+    readonly link: typeof buildLinkFieldSchema;
+    readonly richText: typeof buildRichTextFieldSchema;
+    readonly media: typeof buildMediaFieldSchema;
+    readonly tabGroup: typeof buildTabGroupFieldSchema;
+    readonly presetOrCustom: typeof buildPresetOrCustomFieldSchema;
+    readonly reference: typeof buildReferenceFieldSchema;
+    readonly contentTypeSelect: typeof buildContentTypeSelectFieldSchema;
+    readonly entryPicker: typeof buildEntryPickerFieldSchema;
+};
+export declare const DEFAULT_VALUE_BUILDERS: {
+    readonly text: typeof getTextFieldDefault;
+    readonly number: typeof getNumberFieldDefault;
+    readonly select: typeof getSelectFieldDefault;
+    readonly boolean: typeof getBooleanFieldDefault;
+    readonly group: typeof getGroupFieldDefault;
+    readonly modal: typeof getModalFieldDefault;
+    readonly repeater: typeof getRepeaterFieldDefault;
+    readonly url: typeof getUrlFieldDefault;
+    readonly time: typeof getTimeFieldDefault;
+    readonly date: typeof getDateFieldDefault;
+    readonly datetime: typeof getDateTimeFieldDefault;
+    readonly slug: typeof getSlugFieldDefault;
+    readonly link: typeof getLinkFieldDefault;
+    readonly richText: typeof getRichTextFieldDefaultValue;
+    readonly media: typeof getMediaFieldDefaultValue;
+    readonly tabGroup: typeof getTabGroupFieldDefault;
+    readonly presetOrCustom: typeof getPresetOrCustomFieldDefault;
+    readonly reference: typeof getReferenceFieldDefault;
+    readonly contentTypeSelect: typeof getContentTypeSelectFieldDefault;
+    readonly entryPicker: typeof getEntryPickerFieldDefault;
+};
+export type SchemaBuilderType = keyof typeof SCHEMA_BUILDERS;
+export type DefaultValueBuilderType = keyof typeof DEFAULT_VALUE_BUILDERS;
+/**
+ * Helper to build a validation schema for a single field
+ * Recursively handles nested fields (group, repeater)
+ */
+export declare function buildFieldSchema(field: FieldConfig, ctx: SchemaContext): ZodTypeAny;
+/**
+ * Helper to get default value for a single field
+ * Recursively handles nested fields (group, repeater)
+ */
+export declare function getFieldDefault(field: FieldConfig, ctx: DefaultValueContext): unknown;