@factorialco/f0-react 1.352.0 → 1.353.0

package/dist/f0.d.ts

@@ -104,6 +104,9 @@ import { TextCellValue as TextCellValue_2 } from './types/text';
 import { TrackReferenceOrPlaceholder } from '@livekit/components-react';
 import { ValueDisplayRendererContext } from '../../value-display';
 import { VariantProps } from 'cva';
+import { z } from 'zod';
+import { ZodRawShape } from 'zod';
+import { ZodTypeAny } from 'zod';
 
 export declare function A({ children, ...props }: React.AnchorHTMLAttributes<HTMLAnchorElement>): JSX_2.Element;
 
@@ -770,6 +773,24 @@ export declare type BigNumberProps = {
 
 export declare function Blockquote({ children, ...props }: React.HTMLAttributes<HTMLQuoteElement>): JSX_2.Element;
 
+/**
+ * Base for boolean-specific conditions
+ */
+declare interface BooleanRenderIfBase {
+    fieldId: string;
+}
+
+/**
+ * RenderIf conditions specific to boolean fields
+ */
+export declare type BooleanRenderIfCondition = BooleanRenderIfBase & ({
+    equalsTo: boolean;
+} | {
+    notEqualsTo: boolean;
+} | {
+    isEmpty: boolean;
+});
+
 export declare const buildTranslations: (translations: TranslationsType) => TranslationsType;
 
 /**
@@ -1154,6 +1175,11 @@ export declare const CategoryBarChart: ForwardRefExoticComponent<Omit<CategoryBa
 
 export declare const ChatSpinner: ForwardRefExoticComponent<Omit<SVGProps<SVGSVGElement>, "ref"> & RefAttributes<SVGSVGElement>>;
 
+/**
+ * All valid renderIf conditions for checkbox fields
+ */
+declare type CheckboxFieldRenderIf = BooleanRenderIfCondition | CommonRenderIfCondition;
+
 declare interface CheckboxProps extends DataAttributes_2 {
     /**
      * The title of the checkbox
@@ -1205,6 +1231,11 @@ declare interface CheckboxProps extends DataAttributes_2 {
      * The name of the checkbox
      */
     name?: string;
+    /**
+     * Whether the checkbox is required
+     * @default false
+     */
+    required?: boolean;
 }
 
 declare type ChildrenPaginationInfo = {
@@ -1334,6 +1365,14 @@ values: {
 }) => void) | undefined;
 } & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLElement | SVGElement>>;
 
+/**
+ * Common condition available for all field types
+ */
+export declare type CommonRenderIfCondition = RenderIfBase & {
+    /** Check if the field value is empty (null, undefined, empty string, empty array) */
+    isEmpty: boolean;
+};
+
 export declare type CompanyAvatarVariant = Extract<AvatarVariant, {
     type: "company";
 }>;
@@ -1384,6 +1423,64 @@ export declare type CurrentFilters<F extends FilterOptions<string>> = F extends
     [Key in K]?: FilterValue<F["fields"][Key]>;
 } : Record<string, never>;
 
+/**
+ * All valid renderIf conditions for custom fields
+ */
+declare type CustomFieldRenderIf = CommonRenderIfCondition;
+
+/**
+ * Props passed to the custom field render function
+ *
+ * @typeParam TValue - Type of the field value (inferred from Zod schema)
+ * @typeParam TConfig - Type of the custom configuration object
+ */
+export declare interface CustomFieldRenderProps<TValue = unknown, TConfig = undefined> {
+    /** Field id */
+    id: string;
+    /** Field label */
+    label: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Current field value */
+    value: TValue;
+    /** Callback to update the value */
+    onChange: (value: TValue) => void;
+    /** Callback for blur events */
+    onBlur: () => void;
+    /** Error message if validation failed */
+    error?: string;
+    /** Whether async validation is in progress */
+    isValidating: boolean;
+    /** Whether the field is disabled */
+    disabled?: boolean;
+    /** Custom configuration passed via fieldConfig */
+    config: TConfig;
+}
+
+/**
+ * Base props passed to all custom field render functions (runtime type)
+ */
+declare interface CustomFieldRenderPropsBase {
+    /** Field id */
+    id: string;
+    /** Field label */
+    label: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Current field value */
+    value: unknown;
+    /** Callback to update the value */
+    onChange: (value: unknown) => void;
+    /** Callback for blur events */
+    onBlur: () => void;
+    /** Error message if validation failed */
+    error?: string;
+    /** Whether async validation is in progress */
+    isValidating: boolean;
+    /** Whether the field is disabled */
+    disabled?: boolean;
+}
+
 export declare const Dashboard: ComponentType<DashboardProps_2> & PageLayoutGroupComponent_2;
 
 export declare type DashboardProps = GroupGridProps<DashboardWidget>;
@@ -1632,6 +1729,11 @@ export declare type DataSourceDefinition<R extends RecordType = RecordType, Filt
     }) => number | undefined;
 };
 
+/**
+ * All valid renderIf conditions for date fields
+ */
+declare type DateFieldRenderIf = DateRenderIfCondition | CommonRenderIfCondition;
+
 export declare type DateFilterDefinition = BaseFilterDefinition<"date"> & {
     options?: DateFilterOptions_2;
 };
@@ -1644,6 +1746,11 @@ declare type DateFilterOptions_2 = {
     view?: CalendarView;
 };
 
+/**
+ * Valid granularity keys for date pickers
+ */
+export declare type DateGranularity = "day" | "week" | "month" | "quarter" | "halfyear" | "year" | "range";
+
 declare type DateNavigationOptions = {
     min?: Date;
     max?: Date;
@@ -1707,11 +1814,64 @@ declare type DateRange = {
 
 declare type DateRangeComplete = Required<DateRange>;
 
+/**
+ * All valid renderIf conditions for date range fields
+ */
+declare type DateRangeFieldRenderIf = DateRangeRenderIfCondition | CommonRenderIfCondition;
+
+/**
+ * Base for date range-specific conditions
+ */
+declare interface DateRangeRenderIfBase {
+    fieldId: string;
+}
+
+/**
+ * RenderIf conditions specific to date range fields
+ */
+export declare type DateRangeRenderIfCondition = DateRangeRenderIfBase & {
+    isEmpty: boolean;
+};
+
 declare type DateRangeString = {
     from: string;
     to?: string;
 };
 
+/**
+ * The value type for a date range field
+ */
+export declare interface DateRangeValue {
+    from: Date;
+    to: Date;
+}
+
+/**
+ * Base for date-specific conditions
+ */
+declare interface DateRenderIfBase {
+    fieldId: string;
+}
+
+/**
+ * RenderIf conditions specific to date fields
+ */
+export declare type DateRenderIfCondition = DateRenderIfBase & ({
+    equalsTo: Date;
+} | {
+    notEqualsTo: Date;
+} | {
+    greaterThan: Date;
+} | {
+    greaterThanOrEqual: Date;
+} | {
+    lowerThan: Date;
+} | {
+    lowerThanOrEqual: Date;
+} | {
+    isEmpty: boolean;
+});
+
 declare type DateStringFormat = "default" | "long";
 
 declare type DateValue = {
@@ -2215,6 +2375,45 @@ export declare const defaultTranslations: {
             readonly customPromptPlaceholder: "What do you want to do?";
         };
     };
+    readonly forms: {
+        readonly actionBar: {
+            readonly unsavedChanges: "You have changes pending to be saved";
+            readonly discard: "Discard";
+            readonly issues: {
+                readonly one: "{{count}} issue";
+                readonly other: "{{count}} issues";
+            };
+        };
+        readonly validation: {
+            readonly required: "This field is required";
+            readonly invalidType: "Invalid value";
+            readonly string: {
+                readonly email: "Enter a valid email address";
+                readonly url: "Enter a valid URL";
+                readonly min: "Must be at least {{min}} characters";
+                readonly max: "Must be at most {{max}} characters";
+            };
+            readonly number: {
+                readonly min: "Must be at least {{min}}";
+                readonly max: "Must be at most {{max}}";
+                readonly positive: "Must be a positive number";
+                readonly negative: "Must be a negative number";
+                readonly integer: "Must be a whole number";
+            };
+            readonly date: {
+                readonly min: "Date must be after {{min}}";
+                readonly max: "Date must be before {{max}}";
+                readonly invalid: "Enter a valid date";
+            };
+            readonly array: {
+                readonly min: "Select at least {{min}} option";
+                readonly max: "Select at most {{max}} options";
+            };
+            readonly checkbox: {
+                readonly mustBeChecked: "This option must be selected";
+            };
+        };
+    };
 };
 
 export declare type DialogPosition = (typeof dialogPositions)[number];
@@ -2335,6 +2534,11 @@ export declare interface ErrorMessageProps {
     description: string;
 }
 
+/**
+ * Evaluate a renderIf condition against the current form values
+ */
+export declare function evaluateRenderIf(condition: RenderIfCondition, values: Record<string, unknown>): boolean;
+
 declare type EventCatcherFunction = (eventName: EventName, params: EventParams) => void;
 
 declare interface EventCatcherProviderProps {
@@ -2470,6 +2674,15 @@ export declare interface F0AlertProps {
     variant: AlertVariant;
 }
 
+/**
+ * Config for array fields (multi-select)
+ * @typeParam T - The value type (string or number)
+ * @typeParam R - Record type for data source (when using source instead of options)
+ */
+export declare type F0ArrayConfig<T extends string | number = string, R extends Record<string, unknown> = Record<string, unknown>> = F0BaseConfig & F0SelectConfig<T, R> & {
+    fieldType?: "select";
+};
+
 export declare function F0AuraVoiceAnimation({ size, state, color, colorShift, audioTrack, themeMode, className, ref, ...props }: F0AuraVoiceAnimationProps & ComponentProps<"div"> & VariantProps<typeof F0AuraVoiceAnimationVariants>): JSX_2.Element;
 
 export declare interface F0AuraVoiceAnimationProps {
@@ -2675,6 +2888,45 @@ export declare type F0AvatarTeamProps = {
     badge?: AvatarBadge;
 } & Pick<BaseAvatarProps, "aria-label" | "aria-labelledby">;
 
+/**
+ * Base configuration shared across all field types.
+ * Position is automatically derived from field declaration order in the schema.
+ */
+export declare interface F0BaseConfig {
+    /** Label displayed above the field */
+    label: string;
+    /** Section ID to group field under (null = root level) */
+    section?: string;
+    /** Placeholder text for the input */
+    placeholder?: string;
+    /** Helper text displayed below the field */
+    helpText?: string;
+    /** Whether the field is disabled */
+    disabled?: boolean;
+    /** Row ID for horizontal grouping with other fields */
+    row?: string;
+    /** Conditional rendering based on another field's value */
+    renderIf?: RenderIfCondition;
+}
+
+/**
+ * Base properties shared across all F0 field types
+ */
+export declare interface F0BaseField {
+    /** Unique identifier for the field, used as the form field name */
+    id: string;
+    /** Label displayed above the field */
+    label: string;
+    /** Zod validation schema for the field */
+    validation?: ZodTypeAny;
+    /** Helper text displayed below the field */
+    helpText?: string;
+    /** Placeholder text for the input */
+    placeholder?: string;
+    /** Whether the field is disabled */
+    disabled?: boolean;
+}
+
 export declare const F0BigNumber: {
     ({ label, ...props }: BigNumberProps_2): JSX_2.Element;
     displayName: string;
@@ -2682,6 +2934,25 @@ export declare const F0BigNumber: {
     Skeleton: () => JSX_2.Element;
 };
 
+/**
+ * Config for boolean fields - checkbox
+ */
+declare type F0BooleanCheckboxConfig = F0BaseConfig & F0CheckboxConfig & {
+    fieldType: "checkbox";
+};
+
+/**
+ * Union of all boolean field configs
+ */
+export declare type F0BooleanConfig = F0BooleanCheckboxConfig | F0BooleanSwitchConfig;
+
+/**
+ * Config for boolean fields - switch (default for z.boolean())
+ */
+declare type F0BooleanSwitchConfig = F0BaseConfig & F0SwitchConfig & {
+    fieldType?: "switch";
+};
+
 export declare const F0Button: ForwardRefExoticComponent<Omit<ButtonInternalProps, "style" | "className" | "variant" | "pressed" | "append" | "compact" | "noAutoTooltip" | "noTitle"> & {
 variant?: Exclude<ButtonInternalProps["variant"], "ai">;
 } & RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
@@ -2791,7 +3062,23 @@ export declare type F0CardProps = Omit<CardInternalProps, (typeof privateProps_3
  */
 export declare const F0Checkbox: typeof _F0Checkbox;
 
-declare function _F0Checkbox({ title, onCheckedChange, id, disabled, indeterminate, checked, value, hideLabel, presentational, stopPropagation, name, ...rest }: CheckboxProps): JSX_2.Element;
+declare function _F0Checkbox({ title, onCheckedChange, id, disabled, indeterminate, checked, value, hideLabel, presentational, stopPropagation, name, required, ...rest }: CheckboxProps): JSX_2.Element;
+
+/**
+ * F0 config options specific to checkbox fields
+ * (checkbox has no additional options beyond base config)
+ */
+export declare interface F0CheckboxConfig {
+}
+
+/**
+ * Checkbox field with all properties for rendering
+ */
+export declare type F0CheckboxField = F0BaseField & {
+    type: "checkbox";
+    /** Conditional rendering based on another field's value */
+    renderIf?: CheckboxFieldRenderIf;
+};
 
 /**
  * @experimental This is an experimental component use it at your own risk
@@ -2801,6 +3088,153 @@ export declare const F0ChipList: {
     displayName: string;
 };
 
+/**
+ * F0 config options specific to custom fields
+ *
+ * @typeParam TValue - Type of the field value (inferred from Zod schema)
+ * @typeParam TConfig - Type of the custom configuration object
+ *
+ * @example Without fieldConfig:
+ * ```tsx
+ * f0FormField(z.string(), {
+ *   label: "Employee",
+ *   fieldType: "custom",
+ *   render: ({ value, onChange }) => (
+ *     // value is typed as string
+ *     <EmployeeSelector value={value} onChange={onChange} />
+ *   ),
+ * })
+ * ```
+ *
+ * @example With fieldConfig:
+ * ```tsx
+ * f0FormField(z.array(z.number()), {
+ *   label: "Select employees",
+ *   fieldType: "custom",
+ *   fieldConfig: {
+ *     multiple: true,
+ *     excludeCurrentEmployee: true,
+ *   },
+ *   render: ({ value, onChange, config }) => {
+ *     // value is typed as number[]
+ *     // config is typed as { multiple: boolean, excludeCurrentEmployee: boolean }
+ *     return (
+ *       <EmployeeSelector
+ *         multiple={config.multiple}
+ *         excludeCurrent={config.excludeCurrentEmployee}
+ *         value={value}
+ *         onChange={onChange}
+ *       />
+ *     )
+ *   },
+ * })
+ * ```
+ */
+export declare type F0CustomConfig<TValue = unknown, TConfig = undefined> = TConfig extends undefined ? F0CustomConfigBase<TValue> : F0CustomConfigWithFieldConfig<TValue, TConfig>;
+
+/**
+ * Custom config without fieldConfig (render receives config: undefined)
+ *
+ * @typeParam TValue - Type of the field value
+ */
+declare interface F0CustomConfigBase<TValue = unknown> {
+    /** Render function for the custom component */
+    render: (props: CustomFieldRenderProps<TValue, undefined>) => ReactNode;
+}
+
+/**
+ * Custom config with fieldConfig (render receives typed config)
+ *
+ * @typeParam TValue - Type of the field value
+ * @typeParam TConfig - Type of the fieldConfig object
+ */
+declare interface F0CustomConfigWithFieldConfig<TValue = unknown, TConfig = unknown> {
+    /** Custom configuration to pass to the render function */
+    fieldConfig: TConfig;
+    /** Render function for the custom component */
+    render: (props: CustomFieldRenderProps<TValue, TConfig>) => ReactNode;
+}
+
+/**
+ * Custom field with all properties for rendering (runtime type)
+ */
+export declare type F0CustomField = F0BaseField & {
+    type: "custom";
+    /** Render function for the custom component */
+    render: (props: CustomFieldRenderPropsBase & {
+        config: unknown;
+    }) => ReactNode;
+    /** Custom configuration (if provided) */
+    fieldConfig?: unknown;
+    /** Conditional rendering based on another field's value */
+    renderIf?: CustomFieldRenderIf;
+};
+
+/**
+ * Union of custom field configs (with or without fieldConfig)
+ *
+ * @typeParam TValue - Type of the field value (inferred from Zod schema)
+ * @typeParam TConfig - Type of the fieldConfig object
+ */
+export declare type F0CustomFieldConfig<TValue = unknown, TConfig = undefined> = TConfig extends undefined ? F0CustomFieldConfigBase<TValue> : F0CustomFieldConfigWithConfig<TValue, TConfig>;
+
+/**
+ * Config for custom fields without fieldConfig
+ *
+ * @typeParam TValue - Type of the field value (inferred from Zod schema)
+ */
+declare type F0CustomFieldConfigBase<TValue = unknown> = F0BaseConfig & F0CustomConfig<TValue, undefined> & {
+    fieldType: "custom";
+};
+
+/**
+ * Config for custom fields with fieldConfig
+ *
+ * @typeParam TValue - Type of the field value (inferred from Zod schema)
+ * @typeParam TConfig - Type of the custom configuration object passed to render
+ */
+declare type F0CustomFieldConfigWithConfig<TValue = unknown, TConfig = unknown> = F0BaseConfig & F0CustomConfig<TValue, TConfig> & {
+    fieldType: "custom";
+};
+
+/**
+ * F0 config options specific to date fields
+ *
+ * Note: `minDate`, `maxDate`, and `clearable` are derived from the Zod schema:
+ * - `z.date().min(date)` → minDate
+ * - `z.date().max(date)` → maxDate
+ * - `z.date().optional()` or `z.date().nullable()` → clearable
+ */
+export declare interface F0DateConfig {
+    /** Available granularities for the date picker */
+    granularities?: DateGranularity[];
+    /** Preset date options to display */
+    presets?: DatePreset[];
+}
+
+/**
+ * Date field with all properties for rendering
+ * Includes properties derived from Zod schema
+ */
+export declare type F0DateField = F0BaseField & F0DateConfig & {
+    type: "date";
+    /** Minimum selectable date (derived from z.date().min()) */
+    minDate?: Date;
+    /** Maximum selectable date (derived from z.date().max()) */
+    maxDate?: Date;
+    /** Whether the date can be cleared (derived from optional/nullable) */
+    clearable?: boolean;
+    /** Conditional rendering based on another field's value */
+    renderIf?: DateFieldRenderIf;
+};
+
+/**
+ * Config for date fields
+ */
+export declare type F0DateFieldConfig = F0BaseConfig & F0DateConfig & {
+    fieldType?: "date";
+};
+
 /**
  * @experimental This is an experimental component use it at your own risk
  */
@@ -2813,6 +3247,45 @@ export declare type F0DatePickerProps = Pick<DatePickerPopupProps, "granularitie
     value?: DatePickerValue;
 } & Pick<InputFieldProps<string>, InputFieldInheritedProps>;
 
+/**
+ * F0 config options specific to date range fields
+ *
+ * Note: `minDate`, `maxDate`, and `clearable` are derived from the Zod schema
+ */
+export declare interface F0DateRangeConfig {
+    /** Label for the "from" date input */
+    fromLabel?: string;
+    /** Label for the "to" date input */
+    toLabel?: string;
+    /** Available granularities for the date picker */
+    granularities?: DateGranularity[];
+    /** Preset date options to display */
+    presets?: DatePreset[];
+}
+
+/**
+ * Date range field with all properties for rendering
+ * Includes properties derived from Zod schema
+ */
+export declare type F0DateRangeField = F0BaseField & F0DateRangeConfig & {
+    type: "daterange";
+    /** Minimum selectable date (derived from z.date().min() on the from field) */
+    minDate?: Date;
+    /** Maximum selectable date (derived from z.date().max() on the to field) */
+    maxDate?: Date;
+    /** Whether the date range can be cleared (derived from optional/nullable) */
+    clearable?: boolean;
+    /** Conditional rendering based on another field's value */
+    renderIf?: DateRangeFieldRenderIf;
+};
+
+/**
+ * Config for date range fields
+ */
+export declare type F0DateRangeFieldConfig = F0BaseConfig & F0DateRangeConfig & {
+    fieldType: "daterange";
+};
+
 /**
  * @experimental This is an experimental component use it at your own risk
  */
@@ -2886,6 +3359,23 @@ export declare type F0DropdownButtonProps<T = string> = {
 
 export declare function F0EventCatcherProvider({ children, onEvent, enabled, catchEvents, }: EventCatcherProviderProps): JSX.Element;
 
+/**
+ * Union of all F0 field types used for rendering
+ */
+export declare type F0Field = F0TextField | F0NumberField | F0TextareaField | F0SelectField | F0CheckboxField | F0SwitchField | F0DateField | F0DateRangeField | F0RichTextField | F0CustomField;
+
+/**
+ * Complete F0 field configuration (union of all possible configs)
+ * @typeParam T - The value type for select fields (string or number)
+ * @typeParam R - Record type for data source (when using source instead of options)
+ */
+export declare type F0FieldConfig<T extends string | number = string | number, R extends Record<string, unknown> = Record<string, unknown>> = F0StringConfig<string, undefined, R> | F0NumberFieldConfig<R> | F0BooleanConfig | F0DateFieldConfig | F0ArrayConfig<T, R> | F0ObjectConfig;
+
+/**
+ * Field types for rendering
+ */
+export declare type F0FieldType = "text" | "number" | "textarea" | "select" | "checkbox" | "switch" | "date" | "daterange" | "richtext" | "custom";
+
 /**
  * A standalone dual-pane filter picker content component.
  *
@@ -2956,6 +3446,239 @@ export declare interface F0FilterPickerContentProps<Filters extends FiltersDefin
     width?: number;
 }
 
+/**
+ * @experimental This is an experimental component, use it at your own risk
+ */
+export declare const F0Form: <TSchema extends z.ZodObject<ZodRawShape>>(props: F0FormProps<TSchema>) => React.ReactElement;
+
+/**
+ * Submit configuration for action bar type
+ */
+declare interface F0FormActionBarSubmitConfig extends F0FormSubmitConfigBase {
+    /** Type of submit UI (floating action bar) */
+    type: "action-bar";
+    /** Whether to show a Discard button to reset form changes */
+    discardable?: boolean;
+    /**
+     * Configuration for the discard button (label and icon)
+     * @default { label: "Discard", icon: Delete }
+     */
+    discardConfig?: F0FormDiscardConfig;
+    /** Label shown in the action bar (defaults to i18n "forms.actionBar.unsavedChanges") */
+    actionBarLabel?: string;
+    /**
+     * When true, centers the action bar relative to the ApplicationFrame content area
+     * (accounting for the sidebar width) instead of the full viewport.
+     * @default false
+     */
+    centerActionBarInFrameContent?: boolean;
+}
+
+/**
+ * Submit configuration for default button type
+ */
+declare interface F0FormDefaultSubmitConfig extends F0FormSubmitConfigBase {
+    /**
+     * Type of submit UI
+     * @default "default"
+     */
+    type?: "default";
+}
+
+/**
+ * Configuration for the discard button (action bar only)
+ */
+export declare interface F0FormDiscardConfig {
+    /** Custom label for the discard button */
+    label?: string;
+    /**
+     * Custom icon for the discard button
+     * - undefined: uses default Delete icon
+     * - null: no icon shown
+     * - IconType: custom icon
+     */
+    icon?: IconType | null;
+}
+
+/**
+ * When to trigger and display validation errors
+ * - "on-blur": Errors appear when the user leaves a field (default)
+ * - "on-change": Errors appear as the user types (real-time validation)
+ * - "on-submit": Errors only appear after attempting to submit the form
+ */
+export declare type F0FormErrorTriggerMode = "on-blur" | "on-change" | "on-submit";
+
+/**
+ * String field - text input, textarea, select, or custom
+ * @typeParam R - Record type for data source (when using source instead of options)
+ */
+export declare function f0FormField<T extends z.ZodString, TConfig = undefined, R extends Record<string, unknown> = Record<string, unknown>>(schema: T, config: F0StringConfig<z.infer<T>, TConfig, R>): T & F0ZodType<T>;
+
+/**
+ * Number field - number input or select
+ * @typeParam R - Record type for data source (when using source instead of options)
+ */
+export declare function f0FormField<T extends z.ZodNumber, R extends Record<string, unknown> = Record<string, unknown>>(schema: T, config: F0NumberFieldConfig<R>): T & F0ZodType<T>;
+
+/**
+ * Boolean field - checkbox or switch
+ */
+export declare function f0FormField<T extends z.ZodBoolean>(schema: T, config: F0BooleanConfig): T & F0ZodType<T>;
+
+/**
+ * Date field
+ */
+export declare function f0FormField<T extends z.ZodDate>(schema: T, config: F0DateFieldConfig): T & F0ZodType<T>;
+
+/**
+ * Enum field - select
+ * @typeParam R - Record type for data source (when using source instead of options)
+ */
+export declare function f0FormField<T extends z.ZodEnum<[string, ...string[]]>, R extends Record<string, unknown> = Record<string, unknown>>(schema: T, config: F0StringSelectConfig<R>): T & F0ZodType<T>;
+
+/**
+ * Array field - multi-select
+ * @typeParam V - The element value type (string or number)
+ * @typeParam R - Record type for data source (when using source instead of options)
+ */
+export declare function f0FormField<T extends z.ZodArray<ZodTypeAny>, V extends string | number = string, R extends Record<string, unknown> = Record<string, unknown>>(schema: T, config: F0ArrayConfig<V, R>): T & F0ZodType<T>;
+
+/**
+ * Object field - richtext or custom
+ */
+export declare function f0FormField<T extends z.ZodObject<z.ZodRawShape>, TConfig = undefined>(schema: T, config: F0ObjectConfig<z.infer<T>, TConfig>): T & F0ZodType<T>;
+
+/**
+ * Optional wrapper - inherits inner type's config
+ * @typeParam V - The value type for select fields (string or number)
+ * @typeParam R - Record type for data source (when using source instead of options)
+ */
+export declare function f0FormField<T extends z.ZodOptional<ZodTypeAny>, V extends string | number = string | number, R extends Record<string, unknown> = Record<string, unknown>>(schema: T, config: F0FieldConfig<V, R>): T & F0ZodType<T>;
+
+/**
+ * Nullable wrapper - inherits inner type's config
+ * @typeParam V - The value type for select fields (string or number)
+ * @typeParam R - Record type for data source (when using source instead of options)
+ */
+export declare function f0FormField<T extends z.ZodNullable<ZodTypeAny>, V extends string | number = string | number, R extends Record<string, unknown> = Record<string, unknown>>(schema: T, config: F0FieldConfig<V, R>): T & F0ZodType<T>;
+
+/**
+ * Default wrapper - inherits inner type's config
+ * @typeParam V - The value type for select fields (string or number)
+ * @typeParam R - Record type for data source (when using source instead of options)
+ */
+export declare function f0FormField<T extends z.ZodDefault<ZodTypeAny>, V extends string | number = string | number, R extends Record<string, unknown> = Record<string, unknown>>(schema: T, config: F0FieldConfig<V, R>): T & F0ZodType<T>;
+
+/**
+ * Custom field - works with any schema type
+ * Place before fallback to ensure proper type inference for fieldConfig
+ * TValue is inferred from the Zod schema to provide typed value and onChange
+ */
+export declare function f0FormField<T extends ZodTypeAny, TConfig = undefined>(schema: T, config: F0CustomFieldConfig<z.infer<T>, TConfig>): T & F0ZodType<T>;
+
+/**
+ * Fallback for any other schema type
+ * @typeParam V - The value type for select fields (string or number)
+ * @typeParam R - Record type for data source (when using source instead of options)
+ */
+export declare function f0FormField<T extends ZodTypeAny, V extends string | number = string | number, R extends Record<string, unknown> = Record<string, unknown>>(schema: T, config: F0FieldConfig<V, R>): T & F0ZodType<T>;
+
+/**
+ * Props for the F0Form component
+ *
+ * @typeParam TSchema - The Zod object schema type. The form data type is inferred from this.
+ *
+ * @example
+ * ```tsx
+ * const schema = z.object({
+ *   name: f0FormField(z.string(), { label: "Name" }),
+ *   age: f0FormField(z.number(), { label: "Age" }),
+ * })
+ *
+ * // Default submit button
+ * <F0Form
+ *   name="my-form"
+ *   schema={schema}
+ *   defaultValues={{ name: "" }}
+ *   onSubmit={(data) => ({ success: true })}
+ * />
+ *
+ * // Action bar with discard button
+ * <F0Form
+ *   name="my-form"
+ *   schema={schema}
+ *   submitConfig={{
+ *     type: "action-bar",
+ *     discardable: true,
+ *   }}
+ *   defaultValues={{ name: "" }}
+ *   onSubmit={(data) => ({ success: true })}
+ * />
+ * ```
+ */
+export declare interface F0FormProps<TSchema extends z.ZodObject<ZodRawShape>> {
+    /** Unique name for the form, used for generating anchor links (e.g., #forms.[name].[sectionId].[fieldId]) */
+    name: string;
+    /** Zod object schema with F0 field configurations */
+    schema: TSchema;
+    /** Section configurations keyed by section ID */
+    sections?: Record<string, F0SectionConfig>;
+    /** Default values for the form fields (partial of the schema type) */
+    defaultValues?: Partial<z.infer<TSchema>>;
+    /** Callback when the form is submitted with valid data */
+    onSubmit: (data: z.infer<TSchema>) => Promise<F0FormSubmitResult> | F0FormSubmitResult;
+    /**
+     * Configuration for form submission behavior and appearance
+     * @default { type: "default", label: "Submit", icon: Save }
+     */
+    submitConfig?: F0FormSubmitConfig;
+    /** Additional class name for the form */
+    className?: string;
+    /**
+     * When to trigger and display validation errors
+     * @default "on-blur"
+     */
+    errorTriggerMode?: F0FormErrorTriggerMode;
+}
+
+/**
+ * Type helper for creating a form schema with F0 fields
+ */
+export declare type F0FormSchema<T extends Record<string, ZodTypeAny>> = z.ZodObject<T>;
+
+/**
+ * Configuration for form submission behavior and appearance
+ */
+export declare type F0FormSubmitConfig = F0FormDefaultSubmitConfig | F0FormActionBarSubmitConfig;
+
+/**
+ * Base configuration shared by all submit types
+ */
+declare interface F0FormSubmitConfigBase {
+    /** Custom label for the submit button */
+    label?: string;
+    /**
+     * Custom icon for the submit button
+     * - undefined: uses default Save icon
+     * - null: no icon shown
+     * - IconType: custom icon
+     */
+    icon?: IconType | null;
+}
+
+/**
+ * Result of form submission
+ */
+export declare type F0FormSubmitResult = {
+    success: true;
+} | {
+    success: false;
+    /** Root error message displayed at the top of the form */
+    rootMessage?: string;
+    /** Field-specific error messages */
+    errors?: Record<string, string>;
+};
+
 export declare const F0GridStack: {
     ({ options, widgets, onChange, className, }: F0GridStackProps_2): JSX_2.Element;
     displayName: string;
@@ -3038,6 +3761,63 @@ export declare type F0MessageSourcesProps = {
     sources: F0Source[];
 };
 
+/**
+ * F0 config options specific to number fields
+ *
+ * Note: `min` and `max` are derived from the Zod schema:
+ * - `z.number().min(n)` → min
+ * - `z.number().max(n)` → max
+ */
+export declare interface F0NumberConfig {
+    /** Step value for the number input */
+    step?: number;
+    /** Locale for number formatting */
+    locale?: string;
+}
+
+/**
+ * Number field with all properties for rendering
+ * Includes properties derived from Zod schema
+ */
+export declare type F0NumberField = F0BaseField & F0NumberConfig & {
+    type: "number";
+    /** Minimum value (derived from z.number().min()) */
+    min?: number;
+    /** Maximum value (derived from z.number().max()) */
+    max?: number;
+    /** Conditional rendering based on another field's value */
+    renderIf?: NumberFieldRenderIf;
+};
+
+/**
+ * Config for number fields
+ * @typeParam R - Record type for data source (when using source instead of options)
+ */
+export declare type F0NumberFieldConfig<R extends Record<string, unknown> = Record<string, unknown>> = F0NumberInputConfig | F0NumberSelectConfig<R>;
+
+/**
+ * Config for number fields - number input
+ */
+declare type F0NumberInputConfig = F0BaseConfig & F0NumberConfig & {
+    fieldType?: "number";
+};
+
+/**
+ * Config for number fields - select (for selecting numeric values)
+ * @typeParam R - Record type for data source (when using source instead of options)
+ */
+declare type F0NumberSelectConfig<R extends Record<string, unknown> = Record<string, unknown>> = F0BaseConfig & F0SelectConfig<number, R> & {
+    fieldType: "select";
+};
+
+/**
+ * Config for object fields (richtext, daterange, or custom)
+ *
+ * @typeParam TValue - Type of the field value (for custom fields)
+ * @typeParam TConfig - Type of the custom configuration object (for custom fields)
+ */
+declare type F0ObjectConfig<TValue = unknown, TConfig = undefined> = F0RichTextFieldConfig | F0DateRangeFieldConfig | F0CustomFieldConfig<TValue, TConfig>;
+
 export declare const F0OneIcon: ForwardRefExoticComponent<Omit<F0OneIconProps, "ref"> & RefAttributes<SVGSVGElement>>;
 
 /**
@@ -3082,6 +3862,49 @@ export declare const F0Provider: React.FC<{
     dataCollectionStorageHandler?: DataCollectionStorageHandler;
 }>;
 
+/**
+ * F0 config options specific to rich text fields
+ */
+export declare interface F0RichTextConfig {
+    /** Maximum number of characters allowed */
+    maxCharacters?: number;
+    /** Configuration for user mentions */
+    mentionsConfig?: MentionsConfig;
+    /** Height configuration for the editor */
+    height?: heightType;
+    /** Whether to use plain HTML mode */
+    plainHtmlMode?: boolean;
+}
+
+/**
+ * Rich text field with all properties for rendering
+ */
+export declare type F0RichTextField = F0BaseField & F0RichTextConfig & {
+    type: "richtext";
+    /** Conditional rendering based on another field's value */
+    renderIf?: RichTextFieldRenderIf;
+};
+
+/**
+ * Config for richtext fields
+ */
+export declare type F0RichTextFieldConfig = F0BaseConfig & F0RichTextConfig & {
+    fieldType: "richtext";
+};
+
+/**
+ * Configuration for a form section.
+ * Section order is determined by declaration order in the sections object.
+ */
+export declare interface F0SectionConfig {
+    /** Section title */
+    title: string;
+    /** Section description */
+    description?: string;
+    /** Conditional rendering for the entire section */
+    renderIf?: SectionRenderIf;
+}
+
 /**
  * @experimental This is an experimental component use it at your own risk
  */
@@ -3114,6 +3937,69 @@ declare type F0SelectBaseProps<T extends string, R = unknown> = {
     asList?: boolean;
 };
 
+/**
+ * F0 config options specific to select fields
+ *
+ * Supports either:
+ * - Static `options` array
+ * - Dynamic `source` with `mapOptions` function
+ *
+ * @typeParam T - The value type (string or number)
+ * @typeParam R - Record type from the data source
+ *
+ * Note: `clearable` is derived from the Zod schema:
+ * - `z.string().optional()` or `z.string().nullable()` → clearable
+ */
+export declare type F0SelectConfig<T extends SelectValueType = string, R extends RecordType = RecordType> = F0SelectConfigWithOptions<T> | F0SelectConfigWithSource<T, R>;
+
+/**
+ * Base config options shared by all select field variants
+ */
+declare interface F0SelectConfigBase {
+    /** Whether multiple selection is allowed */
+    multiple?: boolean;
+    /** Whether to show the search box */
+    showSearchBox?: boolean;
+    /** Placeholder for the search box */
+    searchBoxPlaceholder?: string;
+}
+
+/**
+ * Config for select fields with static options
+ * @typeParam T - The value type (string or number)
+ */
+declare interface F0SelectConfigWithOptions<T extends SelectValueType = string> extends F0SelectConfigBase {
+    /** Options for the select dropdown */
+    options: F0SelectItemProps<T, unknown>[];
+    source?: never;
+    mapOptions?: never;
+}
+
+/**
+ * Config for select fields with a data source
+ * @typeParam T - The value type (string or number)
+ * @typeParam R - Record type from the data source
+ */
+declare interface F0SelectConfigWithSource<T extends SelectValueType = string, R extends RecordType = RecordType> extends F0SelectConfigBase {
+    /** Data source for fetching options dynamically */
+    source: DataSourceDefinition<R, FiltersDefinition, SortingsDefinition, GroupingDefinition<R>>;
+    /** Function to map data source items to select options */
+    mapOptions: (item: R) => F0SelectItemProps<T, R>;
+    options?: never;
+}
+
+/**
+ * Select field with all properties for rendering
+ * Includes properties derived from Zod schema
+ */
+export declare type F0SelectField = F0BaseField & F0SelectConfig & {
+    type: "select";
+    /** Whether the select can be cleared (derived from optional/nullable) */
+    clearable?: boolean;
+    /** Conditional rendering based on another field's value */
+    renderIf?: SelectFieldRenderIf;
+};
+
 export declare type F0SelectItemObject<T, R = unknown> = {
     type?: "item";
     value: T;
@@ -3208,6 +4094,53 @@ export declare type F0Source = {
     targetBlank?: boolean;
 };
 
+/**
+ * Union of all string field configs
+ *
+ * @typeParam TValue - Type of the field value (for custom fields)
+ * @typeParam TConfig - Type of the fieldConfig object (for custom fields)
+ * @typeParam R - Record type for data source (when using source instead of options)
+ */
+export declare type F0StringConfig<TValue = string, TConfig = undefined, R extends Record<string, unknown> = Record<string, unknown>> = F0StringTextConfig | F0StringTextareaConfig | F0StringSelectConfig<R> | F0CustomFieldConfig<TValue, TConfig>;
+
+/**
+ * Config for string fields with select options
+ * @typeParam R - Record type for data source (when using source instead of options)
+ */
+declare type F0StringSelectConfig<R extends Record<string, unknown> = Record<string, unknown>> = F0BaseConfig & F0SelectConfig<string, R> & {
+    fieldType?: "select";
+};
+
+/**
+ * Config for string fields - textarea
+ */
+declare type F0StringTextareaConfig = F0BaseConfig & F0TextareaConfig & {
+    fieldType: "textarea";
+};
+
+/**
+ * Config for string fields - text input (default for z.string())
+ */
+declare type F0StringTextConfig = F0BaseConfig & F0TextConfig & {
+    fieldType?: "text";
+};
+
+/**
+ * F0 config options specific to switch fields
+ * (switch has no additional options beyond base config)
+ */
+export declare interface F0SwitchConfig {
+}
+
+/**
+ * Switch field with all properties for rendering
+ */
+export declare type F0SwitchField = F0BaseField & {
+    type: "switch";
+    /** Conditional rendering based on another field's value */
+    renderIf?: SwitchFieldRenderIf;
+};
+
 /**
  * @experimental This is an experimental component use it at your own risk
  */
@@ -3263,6 +4196,46 @@ export declare const F0TagTeam: ForwardRefExoticComponent<TagTeamProps & RefAttr
 
 export declare const F0Text: ForwardRefExoticComponent<Omit<F0TextProps, "ref"> & RefAttributes<HTMLElement>>;
 
+/**
+ * F0 config options specific to textarea fields
+ *
+ * Note: `maxLength` is derived from the Zod schema:
+ * - `z.string().max(n)` → maxLength
+ */
+export declare interface F0TextareaConfig {
+    /** Number of rows for the textarea */
+    rows?: number;
+}
+
+/**
+ * Textarea field with all properties for rendering
+ * Includes properties derived from Zod schema
+ */
+export declare type F0TextareaField = F0BaseField & F0TextareaConfig & {
+    type: "textarea";
+    /** Maximum character length (derived from z.string().max()) */
+    maxLength?: number;
+    /** Conditional rendering based on another field's value */
+    renderIf?: TextareaFieldRenderIf;
+};
+
+/**
+ * F0 config options specific to text fields
+ */
+export declare interface F0TextConfig {
+    /** HTML input type (text, email, password, etc.) */
+    inputType?: "text" | "email" | "password" | "tel" | "url";
+}
+
+/**
+ * Text field with all properties for rendering
+ */
+export declare type F0TextField = F0BaseField & F0TextConfig & {
+    type: "text";
+    /** Conditional rendering based on another field's value */
+    renderIf?: TextFieldRenderIf;
+};
+
 export declare type F0TextProps = Omit<TextProps, "className" | "variant" | "as"> & {
     variant?: (typeof _allowedVariants_2)[number];
     as?: TextTags;
@@ -3301,6 +4274,21 @@ export declare type F0ThinkingProps = {
     title?: string;
 };
 
+/**
+ * Extended Zod type with F0 metadata
+ */
+export declare interface F0ZodType<T extends ZodTypeAny = ZodTypeAny> {
+    _f0Config?: F0FieldConfig;
+    _innerSchema: T;
+}
+
+/* Excluded from this release type: FieldItem */
+
+/**
+ * Field types for rendering
+ */
+export declare type FieldType = "text" | "number" | "textarea" | "select" | "checkbox" | "switch" | "date" | "daterange" | "richtext" | "custom";
+
 export declare type FileAvatarVariant = Extract<AvatarVariant, {
     type: "file";
 }>;
@@ -3467,6 +4455,8 @@ declare type FontSize = (typeof fontSizes)[number];
 
 declare const fontSizes: readonly ["sm", "md", "lg"];
 
+/* Excluded from this release type: FormDefinitionItem */
+
 export declare const FullscreenChatContext: Context<FullscreenChatContextType>;
 
 /**
@@ -3477,6 +4467,12 @@ declare type FullscreenChatContextType = {
     setInProgress: (value: boolean) => void;
 };
 
+/**
+ * Generates an anchor ID for a form element
+ * Format: forms.[formName].[sectionId].[fieldId]
+ */
+export declare function generateAnchorId(formName: string, sectionId?: string, fieldId?: string): string;
+
 export declare const getAnimationVariants: (options?: AnimationVariantsOptions) => {
     hidden: {
         opacity: number;
@@ -3506,6 +4502,21 @@ export declare const getDataSourcePaginationType: <D extends {
 
 export declare function getEmojiLabel(emoji: string): string;
 
+/**
+ * Get F0 config from a schema
+ */
+export declare function getF0Config(schema: ZodTypeAny): F0FieldConfig | undefined;
+
+/**
+ * Non-hook version for extracting definition outside of React components.
+ * Useful for server-side rendering or testing.
+ *
+ * @param schema - Zod object schema with F0 field configurations
+ * @param sections - Optional section configurations keyed by section ID
+ * @returns Array of form definition items
+ */
+export declare function getSchemaDefinition(schema: z.ZodObject<ZodRawShape>, sections?: Record<string, F0SectionConfig>): FormDefinitionItem[];
+
 declare interface GranularityDefinition {
     calendarMode?: CalendarMode;
     calendarView: CalendarView;
@@ -3654,10 +4665,17 @@ export declare function H2({ children, ...props }: React.HTMLAttributes<HTMLHead
 
 export declare function H3({ children, ...props }: React.HTMLAttributes<HTMLHeadingElement>): JSX_2.Element;
 
+/**
+ * Check if a schema has F0 config
+ */
+export declare function hasF0Config(schema: ZodTypeAny): boolean;
+
 declare type HeadingTags = (typeof headingTags)[number];
 
 declare const headingTags: readonly ["h1", "h2", "h3", "h4", "h5", "h6"];
 
+declare type heightType = "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full" | "auto";
+
 export declare const HomeLayout: ForwardRefExoticComponent<Omit<{
 widgets?: ReactNode[];
 children?: ReactNode;
@@ -3713,6 +4731,16 @@ declare type ImageContextValue = {
 
 declare type ImageProps = ImgHTMLAttributes<HTMLImageElement>;
 
+/**
+ * Extract the inferred type from an F0 form schema
+ */
+export declare type InferF0FormValues<T extends z.ZodObject<z.ZodRawShape>> = z.infer<T>;
+
+/**
+ * Infer field type from Zod schema when not explicitly specified
+ */
+export declare function inferFieldType(schema: ZodTypeAny, config: F0FieldConfig): F0FieldType;
+
 export declare type InFilterDefinition<T = string | number, R extends RecordType = RecordType> = BaseFilterDefinition<"in"> & {
     options: InFilterOptions_2<T, R>;
 };
@@ -3782,7 +4810,7 @@ declare const INPUTFIELD_SIZES: readonly ["sm", "md"];
 
 declare type InputFieldInheritedProps = (typeof inputFieldInheritedProps)[number];
 
-declare const inputFieldInheritedProps: readonly ["label", "placeholder", "hideLabel", "size", "error", "disabled", "readonly", "required", "clearable", "labelIcon", "status", "hint"];
+declare const inputFieldInheritedProps: readonly ["label", "placeholder", "hideLabel", "size", "error", "disabled", "readonly", "required", "clearable", "labelIcon", "status", "hint", "loading"];
 
 declare type InputFieldProps<T> = {
     autoFocus?: boolean;
@@ -3885,6 +4913,12 @@ export declare function isInfiniteScrollPagination<R extends RecordType>(paginat
 
 export declare function isPageBasedPagination<R extends RecordType>(pagination: PaginationInfo | null): pagination is PageBasedPaginatedResponse<R>;
 
+/**
+ * Check if a schema is of a specific Zod type using _def.typeName
+ * This is more reliable than instanceof across module boundaries
+ */
+export declare function isZodType(schema: ZodTypeAny, typeName: ZodTypeName): boolean;
+
 declare type ItemActionsDefinition<T extends RecordType> = (item: T) => ActionDefinition[] | undefined;
 
 declare type ItemDefinition = {
@@ -4018,6 +5052,18 @@ export declare interface LoadingStateProps {
 
 declare const MAX_EXPANDED_ACTIONS = 2;
 
+declare type MentionedUser = {
+    id: number;
+    label: string;
+    image_url?: string;
+    href?: string;
+};
+
+declare type MentionsConfig = {
+    onMentionQueryStringChanged?: (queryString: string) => Promise<MentionedUser[]> | undefined;
+    users: MentionedUser[];
+};
+
 declare const moduleAvatarVariants: (props?: ({
     size?: "lg" | "md" | "sm" | "xs" | "xxs" | undefined;
 } & ({
@@ -4162,6 +5208,11 @@ export declare interface NextStepsProps {
     items: StepItemProps[];
 }
 
+/**
+ * All valid renderIf conditions for number fields
+ */
+declare type NumberFieldRenderIf = NumberRenderIfCondition | CommonRenderIfCondition;
+
 export declare type NumberFilterDefinition = BaseFilterDefinition<"number"> & {
     options?: NumberFilterOptions_2;
 };
@@ -4188,6 +5239,32 @@ declare type NumberFilterValue = {
     };
 } | undefined;
 
+/**
+ * Base for number-specific conditions
+ */
+declare interface NumberRenderIfBase {
+    fieldId: string;
+}
+
+/**
+ * RenderIf conditions specific to number fields
+ */
+export declare type NumberRenderIfCondition = NumberRenderIfBase & ({
+    equalsTo: number;
+} | {
+    notEqualsTo: number;
+} | {
+    greaterThan: number;
+} | {
+    greaterThanOrEqual: number;
+} | {
+    lowerThan: number;
+} | {
+    lowerThanOrEqual: number;
+} | {
+    isEmpty: boolean;
+});
+
 export declare type NumberWithFormatter = NumericWithFormatter & {
     animated?: boolean;
 };
@@ -4748,8 +5825,38 @@ declare type RelaxedNumericWithFormatter = Omit<NumericWithFormatter, "numericVa
 
 declare type RendererDefinition = ValueDisplayRendererDefinition;
 
+/**
+ * Base condition that all renderIf conditions must have
+ */
+declare interface RenderIfBase {
+    /** ID of the field to check the condition against */
+    fieldId: string;
+}
+
+/**
+ * Union of all possible RenderIf conditions (used internally for evaluation)
+ */
+export declare type RenderIfCondition = CommonRenderIfCondition | TextRenderIfCondition | NumberRenderIfCondition | BooleanRenderIfCondition | SelectRenderIfCondition | DateRenderIfCondition | DateRangeRenderIfCondition;
+
 export declare type ResolvedRecordType<R> = R extends RecordType ? R : RecordType;
 
+/**
+ * All valid renderIf conditions for richtext fields
+ */
+declare type RichTextFieldRenderIf = CommonRenderIfCondition;
+
+/**
+ * Rich text editor result value type
+ */
+export declare interface RichTextValue {
+    /** HTML content of the editor */
+    value: string | null;
+    /** IDs of mentioned users */
+    mentionIds?: number[];
+}
+
+/* Excluded from this release type: RowDefinition */
+
 export declare type SearchFilterDefinition = BaseFilterDefinition<"search">;
 
 declare type SearchOptions = {
@@ -4785,6 +5892,13 @@ declare type SecondaryActionsDefinition = {
 
 declare type SecondaryActionsItems = SecondaryActionItem[] | SecondaryActionItem[][] | SecondaryActionGroup[];
 
+/* Excluded from this release type: SectionDefinition */
+
+/**
+ * Conditional rendering for sections - can be a condition object or a function
+ */
+export declare type SectionRenderIf = RenderIfCondition | ((values: Record<string, unknown>) => boolean);
+
 /**
  * Represents a collection of selected items.
  * @template T - The type of items in the collection
@@ -4823,6 +5937,11 @@ export declare type SelectedState = {
     checked: boolean;
 };
 
+/**
+ * All valid renderIf conditions for select fields
+ */
+declare type SelectFieldRenderIf = SelectRenderIfCondition | CommonRenderIfCondition;
+
 export declare type SelectionId = number | string;
 
 export declare type SelectionMeta<R extends RecordType> = {
@@ -4849,8 +5968,35 @@ export declare type SelectionStatus<R extends RecordType, Filters extends Filter
     totalKnownItemsCount: number;
 };
 
+/**
+ * Base for select-specific conditions
+ */
+declare interface SelectRenderIfBase {
+    fieldId: string;
+}
+
+/**
+ * RenderIf conditions specific to select fields
+ */
+export declare type SelectRenderIfCondition = SelectRenderIfBase & ({
+    equalsTo: string;
+} | {
+    notEqualsTo: string;
+} | {
+    includes: string;
+} | {
+    notIncludes: string;
+} | {
+    isEmpty: boolean;
+});
+
 export declare const selectSizes: readonly ["sm", "md"];
 
+/**
+ * Value types supported by select fields
+ */
+declare type SelectValueType = string | number;
+
 /**
  * Response structure for non-paginated data
  */
@@ -4921,6 +6067,11 @@ declare type SummaryKey<Definition extends SummariesDefinition> = Definition ext
 
 declare type SummaryType = "sum";
 
+/**
+ * All valid renderIf conditions for switch fields
+ */
+declare type SwitchFieldRenderIf = BooleanRenderIfCondition | CommonRenderIfCondition;
+
 export declare function Table({ children, ...props }: React.HTMLAttributes<HTMLTableElement>): JSX_2.Element;
 
 declare type TableCollectionProps<R extends RecordType, Filters extends FiltersDefinition, Sortings extends SortingsDefinition, Summaries extends SummariesDefinition, ItemActions extends ItemActionsDefinition<R>, NavigationFilters extends NavigationFiltersDefinition, Grouping extends GroupingDefinition<R>> = CollectionProps<R, Filters, Sortings, Summaries, ItemActions, NavigationFilters, Grouping, TableVisualizationOptions<R, Filters, Sortings, Summaries>>;
@@ -5190,6 +6341,16 @@ export declare type TeamAvatarVariant = Extract<AvatarVariant, {
 
 declare type TeamTagProps = ComponentProps<typeof F0TagTeam>;
 
+/**
+ * All valid renderIf conditions for textarea fields
+ */
+declare type TextareaFieldRenderIf = TextRenderIfCondition | CommonRenderIfCondition;
+
+/**
+ * All valid renderIf conditions for text fields
+ */
+declare type TextFieldRenderIf = TextRenderIfCondition | CommonRenderIfCondition;
+
 declare interface TextProps extends Omit<default_2.HTMLAttributes<HTMLElement>, "className">, default_2.RefAttributes<HTMLElement> {
     /**
      * Content to be rendered
@@ -5235,6 +6396,26 @@ declare interface TextProps extends Omit<default_2.HTMLAttributes<HTMLElement>,
     markdown?: boolean;
 }
 
+/**
+ * Base for text-specific conditions
+ */
+declare interface TextRenderIfBase {
+    fieldId: string;
+}
+
+/**
+ * RenderIf conditions specific to text fields
+ */
+export declare type TextRenderIfCondition = TextRenderIfBase & ({
+    equalsTo: string;
+} | {
+    notEqualsTo: string;
+} | {
+    matches: RegExp;
+} | {
+    isEmpty: boolean;
+});
+
 declare type TextTags = (typeof textTags)[number];
 
 declare const textTags: readonly ["p", "span", "div", "label", "code"];
@@ -5315,6 +6496,12 @@ export declare interface TwoColumnLayoutProps {
 
 export declare function Ul({ children, ...props }: React.HTMLAttributes<HTMLUListElement>): JSX_2.Element;
 
+/**
+ * Unwrap optional, nullable, default wrappers to get the inner schema
+ * Uses _def.typeName for reliable type checking across module boundaries
+ */
+export declare function unwrapZodSchema(schema: ZodTypeAny): ZodTypeAny;
+
 declare type UpsellAction = BaseAction & {
     type: "upsell";
     variant: "promote" | "outlinePromote";
@@ -5631,6 +6818,39 @@ export declare const usePrivacyMode: () => {
 
 export declare const useReducedMotion: () => boolean;
 
+/**
+ * Hook to convert a Zod schema with F0 configurations into a FormDefinitionItem array.
+ *
+ * This parses the schema shape, extracts F0 configs, groups fields by section,
+ * sorts by position, and groups row fields together.
+ *
+ * Automatic derivations from the Zod schema:
+ * - **Position**: Derived from field declaration order (can be overridden with `position`)
+ * - **Number min/max**: `z.number().min(n).max(m)` → min/max constraints
+ * - **Date min/max**: `z.date().min(d).max(d)` → minDate/maxDate constraints
+ * - **String maxLength**: `z.string().max(n)` → maxLength for textarea
+ * - **Clearable**: `z.optional()` or `z.nullable()` → clearable for select/date fields
+ *
+ * @param schema - Zod object schema with F0 field configurations
+ * @param sections - Optional section configurations keyed by section ID
+ * @returns Array of form definition items compatible with existing renderers
+ *
+ * @example
+ * ```tsx
+ * const formSchema = z.object({
+ *   // Fields are ordered by declaration - no need to specify position
+ *   firstName: f0FormField(z.string().min(1), { label: "First Name" }),
+ *   lastName: f0FormField(z.string().min(1), { label: "Last Name" }),
+ *   // Constraints derived from Zod, clearable because optional
+ *   birthDate: f0FormField(z.date().min(new Date("1900-01-01")).optional(), {
+ *     label: "Birth Date"
+ *   }),
+ *   age: f0FormField(z.number().min(0).max(120), { label: "Age" })
+ * })
+ * ```
+ */
+export declare function useSchemaDefinition(schema: z.ZodObject<ZodRawShape>, sections?: Record<string, F0SectionConfig>): FormDefinitionItem[];
+
 /**
  * Custom hook to manage selection state for items and groups in a data table
  * Supports single/multi selection, grouped data, pagination, and filtering
@@ -5815,6 +7035,12 @@ declare interface WithTooltipDescription {
     description?: string;
 }
 
+/**
+ * Zod type names for type checking without instanceof
+ * Using _def.typeName is more reliable across module boundaries than instanceof
+ */
+declare type ZodTypeName = "ZodString" | "ZodNumber" | "ZodBoolean" | "ZodDate" | "ZodEnum" | "ZodArray" | "ZodObject" | "ZodOptional" | "ZodNullable" | "ZodDefault" | "ZodLiteral";
+
 export { }
 
 
@@ -5855,11 +7081,6 @@ declare module "gridstack" {
 }
 
 
-declare namespace Calendar {
-    var displayName: string;
-}
-
-
 declare module "@tiptap/core" {
     interface Commands<ReturnType> {
         aiBlock: {
@@ -5896,3 +7117,8 @@ declare module "@tiptap/core" {
         };
     }
 }
+
+
+declare namespace Calendar {
+    var displayName: string;
+}