@riverbankcms/sdk 0.62.2 → 0.64.0

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;

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

@@ -0,0 +1,59 @@
+/**
+ * Widget Component Registry
+ *
+ * Maps field types to their React components.
+ *
+ * ## Type Assertions Rationale
+ *
+ * Each widget is cast to `FieldWidgetComponent` (the base type) to allow storage in a
+ * homogeneous collection, even though each widget has a more specific type signature:
+ *
+ * - TextField: FieldWidgetComponent<string, TextFieldConfig>
+ * - NumberField: FieldWidgetComponent<number, TextFieldConfig>
+ * - GroupField: FieldWidgetComponent<Record<string, any>, GroupFieldConfig>
+ * etc.
+ *
+ * This is a standard TypeScript pattern for heterogeneous registries accessed via
+ * discriminated unions (field.type). The type assertions are safe because:
+ *
+ * 1. **Runtime Correctness**: FormRenderer looks up widgets by field.type, ensuring
+ *    TextField receives TextFieldConfig, GroupField receives GroupFieldConfig, etc.
+ *
+ * 2. **Structural Compatibility**: All field configs extend BaseFieldConfig, so widgets
+ *    can safely access common properties (id, label, description, required, etc.)
+ *
+ * 3. **Widget-Internal Type Safety**: Each widget's implementation is fully typed and
+ *    type-checked against its specific config type.
+ *
+ * ## Context-Dependent Widgets (Not in Registry)
+ *
+ * Some widgets require application-level context and are provided as overrides:
+ *
+ * - MediaField: requires MediaEditorProvider context
+ * - LinkField: requires LinkWidgetContext (siteId, adapters)
+ * - RichTextField: requires RichTextWidgetContext (theme, onPickImage)
+ * - ReferenceField: requires siteId and adapters
+ *
+ * These live in @riverbankcms/editor-blocks and are passed via FormRenderer.widgetOverrides.
+ */
+import type { FieldWidgetComponent } from '../fields/props';
+export declare const WIDGET_COMPONENTS: {
+    readonly text: FieldWidgetComponent;
+    readonly number: FieldWidgetComponent;
+    readonly select: FieldWidgetComponent;
+    readonly sdkSelect: FieldWidgetComponent;
+    readonly boolean: FieldWidgetComponent;
+    readonly group: FieldWidgetComponent;
+    readonly modal: FieldWidgetComponent;
+    readonly tabGroup: FieldWidgetComponent;
+    readonly presetOrCustom: FieldWidgetComponent;
+    readonly repeater: FieldWidgetComponent;
+    readonly url: FieldWidgetComponent;
+    readonly time: FieldWidgetComponent;
+    readonly date: FieldWidgetComponent;
+    readonly datetime: FieldWidgetComponent;
+    readonly slug: FieldWidgetComponent;
+    readonly slider: FieldWidgetComponent;
+};
+export type WidgetType = keyof typeof WIDGET_COMPONENTS;
+export declare function getWidget(type: string): FieldWidgetComponent | undefined;

package/dist/_dts/block-form/src/sdk-config/SdkConfigContext.d.ts

@@ -0,0 +1,110 @@
+import React from 'react';
+import type { FieldDefinition, BlockCategory } from '@riverbankcms/blocks';
+/**
+ * SDK Site Configuration for form widgets
+ *
+ * This context provides SDK config to widgets like BackgroundColorWidget
+ * that need to display SDK-specific options (e.g., curated section backgrounds).
+ */
+export type SdkThemePalette = Record<string, string>;
+export type SdkSectionBackground = {
+    id: string;
+    label: string;
+    token: string;
+};
+export type SdkSectionOptions = {
+    backgroundColor?: boolean;
+    backgroundGradient?: boolean;
+    backgroundImage?: boolean;
+    spacing?: string[] | boolean;
+    textColor?: boolean;
+};
+export type SdkSiteStyleConfig = {
+    sectionBackgrounds?: SdkSectionBackground[];
+    sectionOptions?: SdkSectionOptions;
+};
+/**
+ * SDK Custom Block definition (subset of @riverbankcms/sdk/config types for block-form use)
+ */
+export type SdkCustomBlock = {
+    id: `custom.${string}`;
+    title: string;
+    titleSource?: string | string[];
+    description?: string;
+    category: BlockCategory;
+    icon?: string;
+    tags?: string[];
+    fields: FieldDefinition[];
+};
+/**
+ * Field select option for SDK-provided field options.
+ *
+ * Note: This mirrors FieldSelectOption from @riverbankcms/sdk/config.
+ * block-form is a lightweight package that doesn't depend on SDK,
+ * so these types are defined locally.
+ */
+export type SdkFieldSelectOption = {
+    value: string;
+    label: string;
+};
+/**
+ * Per-field configuration within a block.
+ *
+ * Note: This mirrors BlockFieldConfig from @riverbankcms/sdk/config.
+ */
+export type SdkBlockFieldConfig = {
+    options?: SdkFieldSelectOption[];
+};
+/**
+ * Per-block field options map.
+ *
+ * Note: This mirrors BlockFieldOptionsMap from @riverbankcms/sdk/config.
+ */
+export type SdkBlockFieldOptionsMap = Record<string, Record<string, SdkBlockFieldConfig>>;
+/**
+ * Block field extension configuration.
+ *
+ * Note: This mirrors BlockFieldExtension from @riverbankcms/sdk/config.
+ */
+export type SdkBlockFieldExtension = {
+    fields: FieldDefinition[];
+};
+/**
+ * Per-block field extensions map.
+ *
+ * Note: This mirrors BlockFieldExtensionsMap from @riverbankcms/sdk/config.
+ */
+export type SdkBlockFieldExtensionsMap = Record<string, SdkBlockFieldExtension>;
+export type SdkConfig = {
+    theme?: {
+        palette: SdkThemePalette;
+    };
+    styles?: SdkSiteStyleConfig;
+    customBlocks?: SdkCustomBlock[];
+    blockFieldOptions?: SdkBlockFieldOptionsMap;
+    blockFieldExtensions?: SdkBlockFieldExtensionsMap;
+};
+type SdkConfigContextValue = {
+    sdkConfig: SdkConfig | null;
+    /** Section backgrounds from SDK config */
+    sectionBackgrounds: SdkSectionBackground[] | null;
+    /** Section options from SDK config */
+    sectionOptions: SdkSectionOptions | null;
+    /** Theme palette for resolving tokens to hex values */
+    themePalette: SdkThemePalette | null;
+    /** SDK custom block definitions */
+    customBlocks: SdkCustomBlock[] | null;
+    /** Per-block field options */
+    blockFieldOptions: SdkBlockFieldOptionsMap | null;
+    /** Per-block field extensions (additional fields for built-in blocks) */
+    blockFieldExtensions: SdkBlockFieldExtensionsMap | null;
+    /** Whether this is an SDK site with style config */
+    isSdkSite: boolean;
+};
+export type SdkConfigProviderProps = {
+    sdkConfig: SdkConfig | null | undefined;
+    children: React.ReactNode;
+};
+export declare function SdkConfigProvider({ sdkConfig, children }: SdkConfigProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useSdkConfig(): SdkConfigContextValue;
+export {};

package/dist/_dts/block-form/src/sdk-config/hooks.d.ts

@@ -0,0 +1,21 @@
+import type { SdkBlockFieldConfig } from './SdkConfigContext';
+/**
+ * useBlockFieldOptions
+ *
+ * Hook to get SDK-provided field options for the current block context.
+ * Returns the field config from SDK blockFieldOptions if available.
+ *
+ * @param fieldId - The field ID to look up options for
+ * @returns Field config with options, or null if not found
+ *
+ * @example
+ * ```tsx
+ * function LayoutField({ config }: { config: SelectFieldConfig }) {
+ *   const sdkFieldConfig = useBlockFieldOptions(config.id)
+ *   const options = sdkFieldConfig?.options ?? config.options
+ *
+ *   return <Select options={options} />
+ * }
+ * ```
+ */
+export declare function useBlockFieldOptions(fieldId: string): SdkBlockFieldConfig | null;

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

@@ -0,0 +1,2 @@
+export { SdkConfigProvider, useSdkConfig, type SdkConfig, type SdkConfigProviderProps, type SdkThemePalette, type SdkSectionBackground, type SdkSectionOptions, type SdkSiteStyleConfig, type SdkFieldSelectOption, type SdkBlockFieldConfig, type SdkBlockFieldOptionsMap, type SdkBlockFieldExtensionsMap, } from './SdkConfigContext';
+export { useBlockFieldOptions } from './hooks';

package/dist/_dts/block-form/src/shared/disclosure.d.ts

@@ -0,0 +1 @@
+export { Collapsible as Disclosure, CollapsibleTrigger as DisclosureTrigger, CollapsibleContent as DisclosureContent, } from '@riverbankcms/ui';

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

@@ -0,0 +1,2 @@
+export { useCoarsePointer } from './useCoarsePointer';
+export { useContainerWidth } from './useContainerWidth';

package/dist/_dts/block-form/src/shared/hooks/useCoarsePointer.d.ts

@@ -0,0 +1,5 @@
+type UseCoarsePointerOptions = {
+    mediaQuery?: string;
+};
+export declare function useCoarsePointer(options?: UseCoarsePointerOptions): boolean;
+export {};

package/dist/_dts/block-form/src/shared/hooks/useContainerWidth.d.ts

@@ -0,0 +1,6 @@
+import { type RefObject } from 'react';
+type UseContainerWidthOptions = {
+    defaultWidth?: number;
+};
+export declare function useContainerWidth(ref: RefObject<HTMLElement | null>, options?: UseContainerWidthOptions): number;
+export {};

package/dist/_dts/block-form/src/utils/VisibilityWrapper.d.ts

@@ -0,0 +1,25 @@
+/**
+ * VisibilityWrapper - Reactively shows/hides fields based on visibility conditions
+ *
+ * Uses useBackendWatch to efficiently track only the specific watched field,
+ * avoiding unnecessary re-renders when unrelated fields change.
+ */
+import type { ReactNode } from 'react';
+import type { BaseFieldConfig } from '../fields/types';
+import type { FormBackend } from '../backend/types';
+interface VisibilityWrapperProps {
+    field: BaseFieldConfig;
+    path: string;
+    backend: FormBackend;
+    children: ReactNode;
+}
+/**
+ * Wrapper component that reactively updates visibility
+ *
+ * When a field has ui.visibleWhen:
+ * 1. Uses useBackendWatch to track the watched field (optimized, field-specific)
+ * 2. Re-evaluates visibility when watched value changes
+ * 3. Shows/hides field accordingly
+ */
+export declare function VisibilityWrapper({ field, path, backend, children, }: VisibilityWrapperProps): ReactNode;
+export {};

package/dist/_dts/block-form/src/utils/computeWatchedPath.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Builds the absolute path for a watched field from a relative reference
+ *
+ * @param currentPath - Current field's absolute path (e.g., "background.scale")
+ * @param relativeField - Relative field reference from visibleWhen (e.g., "objectFit")
+ * @returns Absolute path to watched field (e.g., "background.objectFit")
+ *
+ * @example
+ * computeWatchedPath('background.scale', 'objectFit')
+ * // => 'background.objectFit' (sibling field)
+ *
+ * computeWatchedPath('items.0.settings.customColor', 'useCustom')
+ * // => 'items.0.settings.useCustom' (sibling in nested structure)
+ *
+ * computeWatchedPath('subtitle', 'showSubtitle')
+ * // => 'showSubtitle' (top-level sibling)
+ */
+export declare function computeWatchedPath(currentPath: string, relativeField: string | undefined): string | null;

package/dist/_dts/block-form/src/utils/evaluateVisibility.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Utility for evaluating field visibility based on ui.visibleWhen conditions
+ *
+ * This is a pure function with no React dependencies - can be used in any context.
+ * Handles both ui.hidden flag and conditional visibility based on other field values.
+ */
+import type { BaseFieldConfig } from '../fields/types';
+import type { FormBackend } from '../backend/types';
+export declare function evaluateVisibility(field: BaseFieldConfig, backend: FormBackend, path: string): boolean;

package/dist/_dts/block-form/src/utils/fieldHelpers.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Field UI Helper Functions
+ *
+ * Type-safe helpers for accessing field.ui properties.
+ * Reduces repetitive type casting throughout the codebase.
+ */
+import type { FieldConfig } from '../fields/types';
+/**
+ * UI properties that can be set on fields.
+ * This type covers common ui properties used across different field types.
+ */
+export type FieldUiProps = {
+    renderInHeader?: boolean;
+    intent?: FieldIntent;
+    hidden?: boolean;
+    visibleWhen?: unknown;
+    widget?: string;
+    preset?: 'disclosure';
+    modalConfig?: {
+        buttonLabel?: string;
+        description?: string;
+        buttonVariant?: 'outline' | 'default' | 'ghost' | 'secondary';
+        showCustomizedIndicator?: boolean;
+    };
+};
+export type FieldIntent = 'content' | 'display' | 'behavior' | 'style';
+/**
+ * Check if a field should render in the block header.
+ * Header fields are rendered in the collapsed block header area.
+ */
+export declare function isHeaderField(field: FieldConfig): boolean;
+/**
+ * Check if a field is hidden.
+ */
+export declare function isHiddenField(field: FieldConfig): boolean;
+/**
+ * Check if a field has visibility conditions.
+ */
+export declare function hasVisibilityConditions(field: FieldConfig): boolean;
+/**
+ * Get the modal config from a field, if present.
+ */
+export declare function getModalConfig(field: FieldConfig): FieldUiProps['modalConfig'] | undefined;
+/**
+ * Get the widget hint from a field, if present.
+ * Falls back to field.type if no widget is specified.
+ */
+export declare function getWidgetKey(field: FieldConfig): string;
+/**
+ * Resolve semantic intent for top-level form routing.
+ * Priority:
+ * 1) ui.intent (if valid)
+ * 2) default content
+ */
+export declare function getFieldIntent(field: FieldConfig): FieldIntent;
+export declare function partitionFieldsByIntent(fields: FieldConfig[]): {
+    content: FieldConfig[];
+    display: FieldConfig[];
+    behavior: FieldConfig[];
+    style: FieldConfig[];
+};
+/**
+ * Filter out fields that should render in header.
+ * Returns fields that should be rendered in the form body.
+ */
+export declare function filterBodyFields(fields: FieldConfig[]): FieldConfig[];
+/**
+ * Check if a single value is "non-empty" (meaningful).
+ * Returns false for null, undefined, empty string, false, and empty objects/arrays.
+ */
+export declare function isNonEmptyValue(value: unknown): boolean;
+/**
+ * Check if a record has any non-empty values.
+ * Used to determine if a group/modal field has been customized.
+ */
+export declare function hasNonEmptyValues(values: Record<string, unknown> | null | undefined): boolean;
+/**
+ * Type for fields that have nested schema fields (group, modal, repeater).
+ */
+export type FieldWithSchema = FieldConfig & {
+    schema: {
+        fields: FieldConfig[];
+    };
+};
+/**
+ * Check if a field has a nested schema with fields.
+ * Works for group, modal, and monomorphic repeater fields.
+ */
+export declare function hasNestedFields(field: FieldConfig): field is FieldWithSchema;
+/**
+ * Get nested fields from a field config, if present.
+ * Returns empty array if field doesn't have nested fields.
+ */
+export declare function getNestedFields(field: FieldConfig): FieldConfig[];

package/dist/_dts/block-form/src/utils/resolvePromotedFields.d.ts

@@ -0,0 +1,22 @@
+import type { FieldConfig } from '../fields/types';
+import type { TabDefinition } from '../widgets/TabGroupField/types';
+export type ResolvedPromotedField = {
+    /** Absolute backend path to read/write (e.g. `_sectionStyles.background.image`) */
+    path: string;
+    /** Field config to render at the path */
+    field: FieldConfig;
+    /** Optional SDK section option gating for the field (derived from TabGroup tabs). */
+    sdkSectionOption?: TabDefinition['sdkSectionOption'];
+};
+/**
+ * Resolve a list of promoted field paths into renderable field configs.
+ *
+ * Notes:
+ * - This is a render-only shortcut. The returned `field` is *not* added to the
+ *   manifest/schema; it should be rendered at `path` while continuing to store
+ *   data within the existing nested object shape.
+ * - Field IDs in manifests can contain dots (e.g. `overlay.color`). This resolver
+ *   uses greedy matching against child IDs to support those paths.
+ * - Array indexes in paths (e.g. `items.0.title`) are ignored for matching.
+ */
+export declare function resolvePromotedFields(fields: FieldConfig[], promotedPaths: string[] | undefined): ResolvedPromotedField[];

package/dist/_dts/block-form/src/utils/slug.d.ts

@@ -0,0 +1,3 @@
+export declare function slugify(input: string): string;
+export declare function limitSlugLength(value: string, maxLength?: number): string;
+export declare function sanitizeSlugInput(value: string, maxLength?: number): string;

package/dist/_dts/block-form/src/utils/typeGuards.d.ts

@@ -0,0 +1,3 @@
+export type UnknownRecord = Record<string, unknown>;
+export declare function isRecord(value: unknown): value is UnknownRecord;
+export declare function isObjectRecord(value: unknown): value is UnknownRecord;

package/dist/_dts/block-form/src/widgets/BackgroundColorWidget/BackgroundColorField.d.ts

@@ -0,0 +1,10 @@
+/**
+ * BackgroundColorField - Field widget wrapper for BackgroundColorWidget
+ *
+ * Wraps BackgroundColorWidget to work as a standard FieldWidgetComponent.
+ * Reads/writes string values via the form backend.
+ */
+import type { ReactNode } from 'react';
+import type { FieldWidgetProps } from '../../fields/props';
+import type { TextFieldConfig } from '../../fields/types';
+export declare function BackgroundColorField({ path, backend, config, }: FieldWidgetProps<string | null, TextFieldConfig>): ReactNode;

package/dist/_dts/block-form/src/widgets/BackgroundColorWidget/BackgroundColorWidget.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from 'react';
+export type BackgroundColorMode = 'limited' | 'full';
+export type BackgroundColorWidgetProps = {
+    label: string;
+    value: string | null;
+    onChange: (token: string) => void;
+    mode?: BackgroundColorMode;
+    filterTokens?: string[] | null;
+    className?: string;
+    triggerClassName?: string;
+    description?: ReactNode;
+    error?: ReactNode;
+    dataPath?: string;
+};
+/**
+ * BackgroundColorWidget
+ *
+ * Select a background color from the site's theme palette or SDK config.
+ * Automatically uses SDK section backgrounds from context when available.
+ * Otherwise supports 'limited' mode (key shades only) or 'full' mode (all shades).
+ * Optionally filters to only show legible colors via filterTokens prop.
+ */
+export declare function BackgroundColorWidget(props: BackgroundColorWidgetProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+export { BackgroundColorWidget, type BackgroundColorWidgetProps, type BackgroundColorMode } from './BackgroundColorWidget';
+export { BackgroundColorField } from './BackgroundColorField';

package/dist/_dts/block-form/src/widgets/BackgroundGradientWidget/BackgroundGradientField.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from 'react';
+import type { FieldWidgetProps } from '../../fields/props';
+import type { TextFieldConfig } from '../../fields/types';
+/**
+ * BackgroundGradientField
+ *
+ * Field wrapper for BackgroundGradientWidget that integrates with the form system.
+ * Converts between GradientConfig objects (used by the widget) and CSS strings
+ * (stored in the form data).
+ *
+ * This is registered as a widget override with key 'backgroundGradient'.
+ */
+export declare function BackgroundGradientField({ path, backend, config, }: FieldWidgetProps<string | null, TextFieldConfig>): ReactNode;

package/dist/_dts/block-form/src/widgets/BackgroundGradientWidget/BackgroundGradientWidget.d.ts

@@ -0,0 +1,17 @@
+import type { ReactNode } from 'react';
+import type { GradientConfig } from '@riverbankcms/blocks';
+export type BackgroundGradientWidgetProps = {
+    label: string;
+    value: GradientConfig | null;
+    onChange: (config: GradientConfig) => void;
+    description?: ReactNode;
+    error?: ReactNode;
+    dataPath?: string;
+};
+/**
+ * BackgroundGradientWidget
+ *
+ * Select a curated gradient from the theme-based library.
+ * Gradients use theme color tokens, so they adapt to the site's palette.
+ */
+export declare function BackgroundGradientWidget(props: BackgroundGradientWidgetProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+export { BackgroundGradientWidget, type BackgroundGradientWidgetProps } from './BackgroundGradientWidget';
+export { BackgroundGradientField } from './BackgroundGradientField';

package/dist/_dts/block-form/src/widgets/BooleanField/BooleanField.d.ts

@@ -0,0 +1,6 @@
+/**
+ * BooleanField - Boolean switch widget using new FieldWidgetProps pattern with @riverbankcms/ui components
+ */
+import type { FieldWidgetProps } from '../../fields/props';
+import type { BooleanFieldConfig } from '../../fields/types';
+export declare function BooleanField({ path, backend, config }: FieldWidgetProps<boolean, BooleanFieldConfig>): import("react/jsx-runtime").JSX.Element;

package/dist/_dts/block-form/src/widgets/BooleanField/booleanFieldDefaults.d.ts

@@ -0,0 +1,6 @@
+/**
+ * BooleanField default value builder
+ * Server-safe - no React, no browser APIs
+ */
+import type { BooleanFieldConfig } from '../../fields/types';
+export declare function getBooleanFieldDefault(field: BooleanFieldConfig): boolean;

package/dist/_dts/block-form/src/widgets/BooleanField/booleanFieldSchema.d.ts

@@ -0,0 +1,7 @@
+/**
+ * BooleanField validation schema builder
+ * Server-safe - no React, no browser APIs
+ */
+import { z } from 'zod';
+import type { BooleanFieldConfig } from '../../fields/types';
+export declare function buildBooleanFieldSchema(field: BooleanFieldConfig): z.ZodTypeAny;

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

@@ -0,0 +1,3 @@
+export { BooleanField } from './BooleanField';
+export { buildBooleanFieldSchema } from './booleanFieldSchema';
+export { getBooleanFieldDefault } from './booleanFieldDefaults';