@vireocodedev/ui/forms

export type UseVireoMultiStepFormOptions<TFormData, TOnMount extends undefined | FormValidateOrFn<TFormData>, TOnChange extends undefined | FormValidateOrFn<TFormData>, TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnBlur extends undefined | FormValidateOrFn<TFormData>, TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnSubmit extends undefined | FormValidateOrFn<TFormData>, TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnDynamic extends undefined | FormValidateOrFn<TFormData>, TOnDynamicAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>, TSubmitMeta, TSteps extends readonly VireoMultiStepDescriptor<TFormData, string>[]> = FormOptions<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta> & {
    steps: TSteps;
    initialStepId?: StepId<TSteps>;
    onStepChange?: (event: VireoMultiStepChangeEvent<StepId<TSteps>>) => void;
};

Renders an opt-in, object-URL-backed preview for a browser image File.

/**
 * Renders an opt-in, object-URL-backed preview for a browser image File.
 */
export declare const VireoFileImagePreview: React.ForwardRefExoticComponent<Omit<VireoFileImagePreviewProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoFileImagePreview utility classes and theme style overrides.

/** Valid keys for VireoFileImagePreview utility classes and theme style overrides. */
export type VireoFileImagePreviewClassKey = keyof VireoFileImagePreviewClasses;

Utility classes available to VireoFileImagePreview.

/** Utility classes available to VireoFileImagePreview. */
export type VireoFileImagePreviewClasses = Record<VireoFileImagePreviewSlotName | "unavailable", string>;

export interface VireoFileImagePreviewFallbackSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFileImagePreviewImageSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoFileImagePreview inherits from its default root after excluding component-owned props.

/** Props VireoFileImagePreview inherits from its default root after excluding component-owned props. */
export type VireoFileImagePreviewInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

export type VireoFileImagePreviewObjectFit = "contain" | "cover";

Props owned by {@link VireoFileImagePreview }.

/** Props owned by {@link VireoFileImagePreview}. */
export type VireoFileImagePreviewOwnProps = VireoFileImagePreviewSlotsAndSlotProps & {
    /** Alternative text for a semantically meaningful preview. @default '' */
    alt?: string;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoFileImagePreviewClasses>;
    /** Image file to preview. */
    file: File;
    /** How the image fits inside the preview surface. @default 'contain' */
    objectFit?: VireoFileImagePreviewObjectFit;
    /** Content shown when the selected file cannot be previewed. @default 'Preview unavailable' */
    previewUnavailableText?: React.ReactNode;
};

export type VireoFileImagePreviewOwnerState = {
    available: boolean;
    objectFit: VireoFileImagePreviewObjectFit;
};

Props accepted by {@link VireoFileImagePreview }.

/** Props accepted by {@link VireoFileImagePreview}. */
export type VireoFileImagePreviewProps = VireoFileImagePreviewOwnProps & VireoFileImagePreviewInheritedProps;

export interface VireoFileImagePreviewRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoFileImagePreview }.

/** Replaceable semantic regions exposed by {@link VireoFileImagePreview}. */
export type VireoFileImagePreviewSlots = {
    [TSlotName in VireoFileImagePreviewSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoFileImagePreview }.

/** Slot props exposed by {@link VireoFileImagePreview}. */
export type VireoFileImagePreviewSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFileImagePreviewSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoFileImagePreviewRootSlotPropsOverrides, VireoFileImagePreviewOwnerState>;
    /** @default 'img' */
    image: SlotProps<"img", VireoFileImagePreviewImageSlotPropsOverrides, VireoFileImagePreviewOwnerState>;
    /** @default Typography */
    fallback: SlotProps<typeof Typography, VireoFileImagePreviewFallbackSlotPropsOverrides, VireoFileImagePreviewOwnerState>;
}>;

export type VireoFileListCapacityReason = "maxFiles" | "maxTotalSize";

export type VireoFileListRejection = {
    file: File;
    reason: VireoFileListRejectionReason;
};

export type VireoFileListRejectionReason = "type" | "size" | "duplicate" | "maxFiles" | "totalSize";

Component used to render an optional preview for a browser File.

/** Component used to render an optional preview for a browser File. */
export type VireoFilePreviewRenderer = React.ElementType<VireoFilePreviewRendererProps>;

Props supplied to an opt-in Vireo file preview renderer.

/** Props supplied to an opt-in Vireo file preview renderer. */
export type VireoFilePreviewRendererProps = {
    file: File;
};

export type VireoFileRejection = {
    file: File;
    reason: VireoFileRejectionReason;
};

export type VireoFileRejectionReason = "type" | "size";

Keeps form actions in one horizontal row across every containing surface.

/**
 * Keeps form actions in one horizontal row across every containing surface.
 */
export declare const VireoFormActions: React.ForwardRefExoticComponent<Omit<VireoFormActionsProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoFormActions utility classes and theme style overrides.

/** Valid keys for VireoFormActions utility classes and theme style overrides. */
export type VireoFormActionsClassKey = keyof VireoFormActionsClasses;

Utility classes available to VireoFormActions.

/** Utility classes available to VireoFormActions. */
export type VireoFormActionsClasses = Record<VireoFormActionsSlotName, string>;

Props VireoFormActions inherits from its default root after excluding component-owned props.

/** Props VireoFormActions inherits from its default root after excluding component-owned props. */
export type VireoFormActionsInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

export interface VireoFormActionsLayoutSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by {@link VireoFormActions }.

/** Props owned by {@link VireoFormActions}. */
export type VireoFormActionsOwnProps = VireoFormActionsSlotsAndSlotProps & {
    children: React.ReactNode;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoFormActionsClasses>;
};

export type VireoFormActionsOwnerState = Record<string, never>;

Props accepted by {@link VireoFormActions }.

/** Props accepted by {@link VireoFormActions}. */
export type VireoFormActionsProps = VireoFormActionsOwnProps & VireoFormActionsInheritedProps;

export interface VireoFormActionsRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoFormActions }.

/** Replaceable semantic regions exposed by {@link VireoFormActions}. */
export type VireoFormActionsSlots = {
    [TSlotName in VireoFormActionsSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoFormActions }.

/** Slot props exposed by {@link VireoFormActions}. */
export type VireoFormActionsSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormActionsSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoFormActionsRootSlotPropsOverrides, VireoFormActionsOwnerState>;
    /** @default Box */
    layout: SlotProps<typeof Box, VireoFormActionsLayoutSlotPropsOverrides, VireoFormActionsOwnerState>;
}>;

export type VireoFormApi<TFormData, TOnMount extends undefined | FormValidateOrFn<TFormData>, TOnChange extends undefined | FormValidateOrFn<TFormData>, TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnBlur extends undefined | FormValidateOrFn<TFormData>, TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnSubmit extends undefined | FormValidateOrFn<TFormData>, TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnDynamic extends undefined | FormValidateOrFn<TFormData>, TOnDynamicAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>, TSubmitMeta> = Omit<BaseVireoFormApi<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta>, "AppField" | "AppForm" | "Field"> & {
    Field: BaseVireoFormApi<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta>["AppField"];
    Form: React.ForwardRefExoticComponent<VireoFormProps & React.RefAttributes<HTMLFormElement>>;
};

Valid keys for VireoFormAutocompleteField utility classes and theme style overrides.

/** Valid keys for VireoFormAutocompleteField utility classes and theme style overrides. */
export type VireoFormAutocompleteFieldClassKey = keyof VireoFormAutocompleteFieldClasses;

Utility classes available to VireoFormAutocompleteField.

/** Utility classes available to VireoFormAutocompleteField. */
export type VireoFormAutocompleteFieldClasses = Record<VireoFormAutocompleteFieldSlotName | VireoFormAutocompleteFieldStateName, string>;

export type VireoFormAutocompleteFieldFilterState = {
    inputValue: string;
};

export type VireoFormAutocompleteFieldInheritedProps<TOption> = Omit<AutocompleteProps<TOption, false, false, false>, OwnedAutocompleteProp>;

export type VireoFormAutocompleteFieldInputChangeReason = "input" | "reset" | "clear" | "blur" | "selectOption" | "removeOption";

export type VireoFormAutocompleteFieldOwnProps<TOption, TValue extends VireoFormAutocompleteFieldValue> = VireoFormAutocompleteFieldSlotsAndSlotProps & FilterContract<TOption> & {
    label: React.ReactNode;
    options: readonly TOption[];
    getOptionValue: (option: TOption) => TValue;
    getOptionLabel: (option: TOption) => string;
    getOptionDisabled?: (option: TOption) => boolean;
    renderOption?: (option: TOption, state: VireoFormAutocompleteFieldRenderOptionState) => React.ReactNode;
    selectedOption?: TOption;
    getUnresolvedValueLabel?: (value: TValue) => string;
    groupBy?: (option: TOption) => string;
    renderGroupLabel?: (group: string) => React.ReactNode;
    classes?: Partial<VireoFormAutocompleteFieldClasses>;
    disabled?: boolean;
    readOnly?: boolean;
    readOnlyEmptyValue?: React.ReactNode;
    renderReadOnlyValue?: (value: TValue, selection: VireoFormAutocompleteFieldSelection<TOption, TValue>) => React.ReactNode;
    required?: boolean;
    error?: boolean;
    errorDisplay?: VireoFormErrorDisplay;
    formatError?: VireoFormErrorFormatter;
    /** Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    fullWidth?: boolean;
    placeholder?: string;
    variant?: TextFieldProps["variant"];
    size?: TextFieldProps["size"];
    color?: TextFieldProps["color"];
    margin?: TextFieldProps["margin"];
    inputRef?: React.Ref<HTMLInputElement>;
    inputValue?: string;
    defaultInputValue?: string;
    onBlur?: React.FocusEventHandler<HTMLInputElement>;
    onInputValueChange?: (value: string, reason: VireoFormAutocompleteFieldInputChangeReason) => void;
    onValueChange?: (value: TValue | null, details: VireoFormAutocompleteFieldValueChangeDetails<TOption, TValue>) => void;
    loading?: boolean;
    loadingText?: React.ReactNode;
    noOptionsText?: React.ReactNode;
    disableClearable?: boolean;
    clearOnEscape?: boolean;
    clearLabel?: string;
    openLabel?: string;
    closeLabel?: string;
    open?: boolean;
    defaultOpen?: boolean;
    onOpen?: () => void;
    onClose?: NonNullable<AutocompleteProps<TOption, false, false, false>["onClose"]>;
    clearIcon?: React.ReactNode;
    popupIcon?: React.ReactNode;
};

export type VireoFormAutocompleteFieldOwnerState = {
    dirty: boolean;
    disabled: boolean;
    error: boolean;
    focused: boolean;
    hasInputValue: boolean;
    hasUnresolvedValue: boolean;
    hasValue: boolean;
    loading: boolean;
    open: boolean;
    readOnly: boolean;
    required: boolean;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
};

export type VireoFormAutocompleteFieldProps<TOption = unknown, TValue extends VireoFormAutocompleteFieldValue = VireoFormAutocompleteFieldValue> = VireoFormAutocompleteFieldOwnProps<TOption, TValue> & VireoFormAutocompleteFieldInheritedProps<TOption>;

export type VireoFormAutocompleteFieldRenderOptionState = {
    inputValue: string;
    selected: boolean;
    disabled: boolean;
    index: number;
};

export type VireoFormAutocompleteFieldSelection<TOption, TValue extends VireoFormAutocompleteFieldValue> = {
    value: TValue;
    label: string;
    resolved: boolean;
    option: TOption | null;
};

export interface VireoFormAutocompleteFieldSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormAutocompleteFieldSlots = {
    root: React.ElementType;
    textField: React.ElementType;
    inputLabel: React.ElementType;
    input: React.ElementType;
    htmlInput: React.ElementType;
    loadingIndicator: React.ElementType;
    clearButton: React.ElementType;
    clearIcon: React.ElementType;
    popupButton: React.ElementType;
    popupIcon: React.ElementType;
    formHelperText: React.ElementType;
    popper: React.ElementType;
    paper: React.ElementType;
    loadingText: React.ElementType;
    noOptionsText: React.ElementType;
    listbox: React.ElementType;
    option: React.ElementType;
    group: React.ElementType;
    groupLabel: React.ElementType;
    groupList: React.ElementType;
};

export type VireoFormAutocompleteFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormAutocompleteFieldSlots, {
    root: CommonSlotProps<typeof Box>;
    textField: CommonSlotProps<typeof TextField>;
    inputLabel: CommonSlotProps<typeof InputLabel>;
    input: CommonSlotProps<"div">;
    htmlInput: CommonSlotProps<"input">;
    loadingIndicator: CommonSlotProps<typeof CircularProgress>;
    clearButton: CommonSlotProps<typeof IconButton>;
    clearIcon: CommonSlotProps<"svg">;
    popupButton: CommonSlotProps<typeof IconButton>;
    popupIcon: CommonSlotProps<"svg">;
    formHelperText: CommonSlotProps<typeof FormHelperText>;
    popper: CommonSlotProps<typeof Popper>;
    paper: CommonSlotProps<typeof Paper>;
    loadingText: CommonSlotProps<"div">;
    noOptionsText: CommonSlotProps<"div">;
    listbox: CommonSlotProps<"ul">;
    option: CommonSlotProps<"li">;
    group: CommonSlotProps<"li">;
    groupLabel: CommonSlotProps<typeof ListSubheader>;
    groupList: CommonSlotProps<"ul">;
}>;

export type VireoFormAutocompleteFieldValue = string | number;

export type VireoFormAutocompleteFieldValueChangeDetails<TOption, TValue extends VireoFormAutocompleteFieldValue> = {
    reason: "selectOption";
    option: TOption;
    value: TValue;
} | {
    reason: "clear";
    previousValue: TValue | null;
};

Valid keys for VireoFormAutocompleteMultipleField utility classes and theme style overrides.

/** Valid keys for VireoFormAutocompleteMultipleField utility classes and theme style overrides. */
export type VireoFormAutocompleteMultipleFieldClassKey = keyof VireoFormAutocompleteMultipleFieldClasses;

Utility classes available to VireoFormAutocompleteMultipleField.

/** Utility classes available to VireoFormAutocompleteMultipleField. */
export type VireoFormAutocompleteMultipleFieldClasses = Record<VireoFormAutocompleteMultipleFieldSlotName | VireoFormAutocompleteMultipleFieldStateName, string>;

export type VireoFormAutocompleteMultipleFieldFilterState = {
    inputValue: string;
};

export type VireoFormAutocompleteMultipleFieldInheritedProps<TOption> = Omit<AutocompleteProps<TOption, true, false, false>, OwnedAutocompleteProp>;

export type VireoFormAutocompleteMultipleFieldInputChangeReason = "input" | "reset" | "clear" | "blur" | "selectOption" | "removeOption";

export type VireoFormAutocompleteMultipleFieldOwnProps<TOption, TValue extends VireoFormAutocompleteMultipleFieldValue> = VireoFormAutocompleteMultipleFieldSlotsAndSlotProps & FilterContract<TOption> & {
    label: React.ReactNode;
    options: readonly TOption[];
    getOptionValue: (option: TOption) => TValue;
    getOptionLabel: (option: TOption) => string;
    getOptionDisabled?: (option: TOption) => boolean;
    renderOption?: (option: TOption, state: VireoFormAutocompleteMultipleFieldRenderOptionState) => React.ReactNode;
    selectedOptions?: readonly TOption[];
    getUnresolvedValueLabel?: (value: TValue) => string;
    groupBy?: (option: TOption) => string;
    renderGroupLabel?: (group: string) => React.ReactNode;
    renderSelectedOptions?: (params: VireoFormAutocompleteMultipleFieldRenderSelectedOptionsParams<TOption, TValue>) => React.ReactNode;
    maxDisplayedOptions?: number;
    maxSelectedOptions?: number;
    getHiddenOptionsText?: (count: number) => React.ReactNode;
    getHiddenOptionsLabel?: (count: number) => string;
    getRemoveOptionLabel?: (selection: VireoFormAutocompleteMultipleFieldSelection<TOption, TValue>) => string;
    hideOptionCheckbox?: boolean;
    removeOnBackspace?: boolean;
    classes?: Partial<VireoFormAutocompleteMultipleFieldClasses>;
    disabled?: boolean;
    readOnly?: boolean;
    readOnlyEmptyValue?: React.ReactNode;
    renderReadOnlyValue?: (values: readonly TValue[], selections: readonly VireoFormAutocompleteMultipleFieldSelection<TOption, TValue>[]) => React.ReactNode;
    required?: boolean;
    error?: boolean;
    errorDisplay?: VireoFormErrorDisplay;
    formatError?: VireoFormErrorFormatter;
    /** Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    fullWidth?: boolean;
    placeholder?: string;
    variant?: TextFieldProps["variant"];
    size?: TextFieldProps["size"];
    color?: TextFieldProps["color"];
    margin?: TextFieldProps["margin"];
    inputRef?: React.Ref<HTMLInputElement>;
    inputValue?: string;
    defaultInputValue?: string;
    onBlur?: React.FocusEventHandler<HTMLInputElement>;
    onInputValueChange?: (value: string, reason: VireoFormAutocompleteMultipleFieldInputChangeReason) => void;
    onValueChange?: (value: TValue[], details: VireoFormAutocompleteMultipleFieldValueChangeDetails<TOption, TValue>) => void;
    loading?: boolean;
    loadingText?: React.ReactNode;
    noOptionsText?: React.ReactNode;
    disableClearable?: boolean;
    clearOnEscape?: boolean;
    clearLabel?: string;
    openLabel?: string;
    closeLabel?: string;
    open?: boolean;
    defaultOpen?: boolean;
    onOpen?: () => void;
    onClose?: NonNullable<AutocompleteProps<TOption, true, false, false>["onClose"]>;
    clearIcon?: React.ReactNode;
    popupIcon?: React.ReactNode;
};

export type VireoFormAutocompleteMultipleFieldOwnerState = {
    dirty: boolean;
    disabled: boolean;
    error: boolean;
    focused: boolean;
    hasInputValue: boolean;
    hasUnresolvedValue: boolean;
    hasValue: boolean;
    loading: boolean;
    open: boolean;
    readOnly: boolean;
    required: boolean;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
    atSelectionLimit: boolean;
    hasHiddenOptions: boolean;
};

export type VireoFormAutocompleteMultipleFieldProps<TOption = unknown, TValue extends VireoFormAutocompleteMultipleFieldValue = VireoFormAutocompleteMultipleFieldValue> = VireoFormAutocompleteMultipleFieldOwnProps<TOption, TValue> & VireoFormAutocompleteMultipleFieldInheritedProps<TOption>;

export type VireoFormAutocompleteMultipleFieldRenderOptionState = {
    inputValue: string;
    selected: boolean;
    disabled: boolean;
    index: number;
};

export type VireoFormAutocompleteMultipleFieldRenderSelectedOptionsParams<TOption, TValue extends VireoFormAutocompleteMultipleFieldValue> = {
    selections: readonly VireoFormAutocompleteMultipleFieldSelection<TOption, TValue>[];
    displayedSelections: readonly VireoFormAutocompleteMultipleFieldSelection<TOption, TValue>[];
    hiddenCount: number;
    maxDisplayedOptions: number;
    getRemoveButtonProps: (value: TValue) => {
        "aria-label": string;
        disabled: boolean;
        onClick: React.MouseEventHandler<HTMLButtonElement>;
    };
};

export type VireoFormAutocompleteMultipleFieldSelection<TOption, TValue extends VireoFormAutocompleteMultipleFieldValue> = {
    value: TValue;
    label: string;
    resolved: boolean;
    option: TOption | null;
};

export interface VireoFormAutocompleteMultipleFieldSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormAutocompleteMultipleFieldSlots = {
    root: React.ElementType;
    textField: React.ElementType;
    inputLabel: React.ElementType;
    input: React.ElementType;
    htmlInput: React.ElementType;
    loadingIndicator: React.ElementType;
    clearButton: React.ElementType;
    clearIcon: React.ElementType;
    popupButton: React.ElementType;
    popupIcon: React.ElementType;
    formHelperText: React.ElementType;
    popper: React.ElementType;
    paper: React.ElementType;
    loadingText: React.ElementType;
    noOptionsText: React.ElementType;
    listbox: React.ElementType;
    option: React.ElementType;
    group: React.ElementType;
    groupLabel: React.ElementType;
    groupList: React.ElementType;
    selectedOptions: React.ElementType;
    selectedOption: React.ElementType;
    selectedOptionDeleteIcon: React.ElementType;
    hiddenOptionsButton: React.ElementType;
    optionCheckbox: React.ElementType;
};

export type VireoFormAutocompleteMultipleFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormAutocompleteMultipleFieldSlots, {
    root: CommonSlotProps<typeof Box>;
    textField: CommonSlotProps<typeof TextField>;
    inputLabel: CommonSlotProps<typeof InputLabel>;
    input: CommonSlotProps<"div">;
    htmlInput: CommonSlotProps<"input">;
    loadingIndicator: CommonSlotProps<typeof CircularProgress>;
    clearButton: CommonSlotProps<typeof IconButton>;
    clearIcon: CommonSlotProps<"svg">;
    popupButton: CommonSlotProps<typeof IconButton>;
    popupIcon: CommonSlotProps<"svg">;
    formHelperText: CommonSlotProps<typeof FormHelperText>;
    popper: CommonSlotProps<typeof Popper>;
    paper: CommonSlotProps<typeof Paper>;
    loadingText: CommonSlotProps<"div">;
    noOptionsText: CommonSlotProps<"div">;
    listbox: CommonSlotProps<"ul">;
    option: CommonSlotProps<"li">;
    group: CommonSlotProps<"li">;
    groupLabel: CommonSlotProps<typeof ListSubheader>;
    groupList: CommonSlotProps<"ul">;
    selectedOptions: CommonSlotProps<"div">;
    selectedOption: CommonSlotProps<typeof Chip>;
    selectedOptionDeleteIcon: CommonSlotProps<"svg">;
    hiddenOptionsButton: CommonSlotProps<typeof Button>;
    optionCheckbox: CommonSlotProps<typeof Checkbox>;
}>;

export type VireoFormAutocompleteMultipleFieldValue = string | number;

export type VireoFormAutocompleteMultipleFieldValueChangeDetails<TOption, TValue extends VireoFormAutocompleteMultipleFieldValue> = {
    reason: "selectOption";
    option: TOption;
    value: TValue;
} | {
    reason: "removeOption";
    option: TOption | null;
    value: TValue;
} | {
    reason: "clear";
    previousValues: TValue[];
};

export interface VireoFormCheckboxFieldCheckboxSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
    /** Compatibility alias merged into MUI's native `input` slot. */
    inputProps?: React.InputHTMLAttributes<HTMLInputElement>;
    /** Compatibility alias forwarded to MUI's native `input` slot. */
    inputRef?: React.Ref<HTMLInputElement>;
}

Valid keys for VireoFormCheckboxField utility classes and theme style overrides.

/** Valid keys for VireoFormCheckboxField utility classes and theme style overrides. */
export type VireoFormCheckboxFieldClassKey = keyof VireoFormCheckboxFieldClasses;

Utility classes available to VireoFormCheckboxField.

/** Utility classes available to VireoFormCheckboxField. */
export type VireoFormCheckboxFieldClasses = Record<VireoFormCheckboxFieldSlotName | VireoFormCheckboxFieldStateName, string>;

export interface VireoFormCheckboxFieldFormControlLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormCheckboxFieldFormHelperTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoFormCheckboxField inherits from its default root after excluding component-owned props.

/** Props VireoFormCheckboxField inherits from its default root after excluding component-owned props. */
export type VireoFormCheckboxFieldInheritedProps = Omit<FormControlProps, VireoFormCheckboxFieldComponentOwnedProp>;

export interface VireoFormCheckboxFieldLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by the bound form checkbox field. The field name and checked value remain owned by `form.Field`.

/** Props owned by the bound form checkbox field. The field name and checked value remain owned by `form.Field`. */
export type VireoFormCheckboxFieldOwnProps = VireoFormCheckboxFieldSlotsAndSlotProps & {
    /** Override or extend the utility classes applied to each slot and state. */
    classes?: Partial<VireoFormCheckboxFieldClasses>;
    disabled?: boolean;
    /** Adds an error presentation state without suppressing validation errors. */
    error?: boolean;
    /** Overrides the enclosing form's error-display policy for this field. */
    errorDisplay?: VireoFormErrorDisplay;
    /** Overrides the enclosing form's validation-error formatter for this field. */
    formatError?: VireoFormErrorFormatter;
    /** @default true */
    fullWidth?: boolean;
    /** Shown when no visible validation error takes precedence. Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    /** Ref forwarded to the native checkbox input. */
    inputRef?: React.Ref<HTMLInputElement>;
    /** Visible accessible label rendered beside the checkbox. */
    label: React.ReactNode;
    /** @default 'end' */
    labelPlacement?: FormControlLabelProps["labelPlacement"];
    onBlur?: NonNullable<CheckboxProps["onBlur"]>;
    onChange?: NonNullable<CheckboxProps["onChange"]>;
    readOnly?: boolean;
    readOnlyEmptyValue?: React.ReactNode;
    renderReadOnlyValue?: (value: boolean) => React.ReactNode;
    required?: boolean;
};

export type VireoFormCheckboxFieldOwnerState = {
    checked: boolean;
    dirty: boolean;
    disabled: boolean;
    errorVisible: boolean;
    invalid: boolean;
    readOnly: boolean;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
};

Props accepted by `field.CheckboxField`.

/** Props accepted by `field.CheckboxField`. */
export type VireoFormCheckboxFieldProps = VireoFormCheckboxFieldOwnProps & VireoFormCheckboxFieldInheritedProps;

export interface VireoFormCheckboxFieldRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by the bound form checkbox field.

/** Replaceable semantic regions exposed by the bound form checkbox field. */
export type VireoFormCheckboxFieldSlots = {
    root: React.ElementType;
    formControlLabel: React.ElementType;
    checkbox: React.ElementType;
    label: React.ElementType;
    formHelperText: React.ElementType;
};

Slot props exposed by the bound form checkbox field.

/** Slot props exposed by the bound form checkbox field. */
export type VireoFormCheckboxFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormCheckboxFieldSlots, {
    /** @default FormControl */
    root: SlotProps<typeof FormControl, VireoFormCheckboxFieldRootSlotPropsOverrides, VireoFormCheckboxFieldOwnerState>;
    /** @default FormControlLabel */
    formControlLabel: SlotProps<typeof FormControlLabel, VireoFormCheckboxFieldFormControlLabelSlotPropsOverrides, VireoFormCheckboxFieldOwnerState>;
    /** @default Checkbox */
    checkbox: SlotProps<typeof Checkbox, VireoFormCheckboxFieldCheckboxSlotPropsOverrides, VireoFormCheckboxFieldOwnerState>;
    /** @default Typography */
    label: SlotProps<typeof Typography, VireoFormCheckboxFieldLabelSlotPropsOverrides, VireoFormCheckboxFieldOwnerState>;
    /** @default FormHelperText */
    formHelperText: SlotProps<typeof FormHelperText, VireoFormCheckboxFieldFormHelperTextSlotPropsOverrides, VireoFormCheckboxFieldOwnerState>;
}>;

Valid keys for VireoForm utility classes and theme style overrides.

/** Valid keys for VireoForm utility classes and theme style overrides. */
export type VireoFormClassKey = keyof VireoFormClasses;

Utility classes available to VireoForm.

/** Utility classes available to VireoForm. */
export type VireoFormClasses = Record<VireoFormSlotName | VireoFormStateName, string>;

Accessible naming contract for the counter and its numeric input.

/** Accessible naming contract for the counter and its numeric input. */
export type VireoFormCounterFieldAccessibleNameProps = {
    "aria-label": string;
    "aria-labelledby"?: string;
} | {
    "aria-label"?: undefined;
    "aria-labelledby": string;
};

Valid keys for VireoFormCounterField utility classes and theme style overrides.

/** Valid keys for VireoFormCounterField utility classes and theme style overrides. */
export type VireoFormCounterFieldClassKey = keyof VireoFormCounterFieldClasses;

Utility classes available to VireoFormCounterField.

/** Utility classes available to VireoFormCounterField. */
export type VireoFormCounterFieldClasses = Record<VireoFormCounterFieldSlotName | VireoFormCounterFieldStateName, string>;

export interface VireoFormCounterFieldDecrementButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormCounterFieldDecrementIconSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormCounterFieldFormHelperTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormCounterFieldHtmlInputSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormCounterFieldIncrementButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormCounterFieldIncrementIconSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoFormCounterField inherits from its default root after excluding component-owned props.

/** Props VireoFormCounterField inherits from its default root after excluding component-owned props. */
export type VireoFormCounterFieldInheritedProps = Omit<FormControlProps, ComponentOwnedProp>;

export interface VireoFormCounterFieldInputSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by the bound counter field. The field name and value remain owned by `form.Field`.

/** Props owned by the bound counter field. The field name and value remain owned by `form.Field`. */
export type VireoFormCounterFieldOwnProps = VireoFormCounterFieldSlotsAndSlotProps & {
    classes?: Partial<VireoFormCounterFieldClasses>;
    disabled?: boolean;
    /** Accessible label for the decrement control. @default 'Decrease' */
    decrementLabel?: string;
    /** Adds an error presentation state without suppressing validation errors. */
    error?: boolean;
    /** Overrides the enclosing form's error-display policy for this field. */
    errorDisplay?: VireoFormErrorDisplay;
    /** Overrides the enclosing form's validation-error formatter for this field. */
    formatError?: VireoFormErrorFormatter;
    /** @default true */
    fullWidth?: boolean;
    /** Shown when no visible validation error takes precedence. Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    /** Accessible label for the increment control. @default 'Increase' */
    incrementLabel?: string;
    /** Ref forwarded to the native numeric text input. */
    inputRef?: React.Ref<HTMLInputElement>;
    /** Largest value emitted by user interaction. */
    max?: number;
    /** Smallest value emitted by user interaction. */
    min?: number;
    onBlur?: React.FocusEventHandler<HTMLDivElement>;
    onChange?: React.ChangeEventHandler<HTMLInputElement>;
    /** Called after a complete edit or step resolves to a different stored value. */
    onValueChange?: (value: number | null) => void;
    readOnly?: boolean;
    readOnlyEmptyValue?: React.ReactNode;
    renderReadOnlyValue?: (value: number) => React.ReactNode;
    required?: boolean;
    /** @default 'medium' */
    size?: VireoFormCounterFieldSize;
    /** Positive finite amount used by buttons and Arrow keys. @default 1 */
    step?: number;
    /** Additional description IDs applied to the numeric input. */
    "aria-describedby"?: string;
};

export type VireoFormCounterFieldOwnerState = {
    atMax: boolean;
    atMin: boolean;
    decrementDisabled: boolean;
    dirty: boolean;
    disabled: boolean;
    errorVisible: boolean;
    fullWidth: boolean;
    hasValue: boolean;
    incrementDisabled: boolean;
    invalid: boolean;
    max: number | undefined;
    min: number | undefined;
    readOnly: boolean;
    required: boolean;
    size: VireoFormCounterFieldSize;
    step: number;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
};

Props accepted by `field.CounterField`.

/** Props accepted by `field.CounterField`. */
export type VireoFormCounterFieldProps = VireoFormCounterFieldOwnProps & VireoFormCounterFieldAccessibleNameProps & VireoFormCounterFieldInheritedProps;

export interface VireoFormCounterFieldRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormCounterFieldSize = "small" | "medium";

Replaceable semantic regions exposed by the bound counter field.

/** Replaceable semantic regions exposed by the bound counter field. */
export type VireoFormCounterFieldSlots = {
    root: React.ElementType;
    input: React.ElementType;
    decrementButton: React.ElementType;
    decrementIcon: React.ElementType;
    htmlInput: React.ElementType;
    incrementButton: React.ElementType;
    incrementIcon: React.ElementType;
    formHelperText: React.ElementType;
};

Slot props exposed by the bound counter field.

/** Slot props exposed by the bound counter field. */
export type VireoFormCounterFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormCounterFieldSlots, {
    /** @default FormControl */
    root: SlotProps<typeof FormControl, VireoFormCounterFieldRootSlotPropsOverrides, VireoFormCounterFieldOwnerState>;
    /** @default OutlinedInput */
    input: SlotProps<typeof OutlinedInput, VireoFormCounterFieldInputSlotPropsOverrides, VireoFormCounterFieldOwnerState>;
    /** @default IconButton */
    decrementButton: SlotProps<typeof IconButton, VireoFormCounterFieldDecrementButtonSlotPropsOverrides, VireoFormCounterFieldOwnerState>;
    /** @default RemoveIcon */
    decrementIcon: SlotProps<typeof SvgIcon, VireoFormCounterFieldDecrementIconSlotPropsOverrides, VireoFormCounterFieldOwnerState>;
    /** @default 'input' */
    htmlInput: SlotProps<"input", VireoFormCounterFieldHtmlInputSlotPropsOverrides, VireoFormCounterFieldOwnerState>;
    /** @default IconButton */
    incrementButton: SlotProps<typeof IconButton, VireoFormCounterFieldIncrementButtonSlotPropsOverrides, VireoFormCounterFieldOwnerState>;
    /** @default AddIcon */
    incrementIcon: SlotProps<typeof SvgIcon, VireoFormCounterFieldIncrementIconSlotPropsOverrides, VireoFormCounterFieldOwnerState>;
    /** @default FormHelperText */
    formHelperText: SlotProps<typeof FormHelperText, VireoFormCounterFieldFormHelperTextSlotPropsOverrides, VireoFormCounterFieldOwnerState>;
}>;

Controls when field errors are presented without changing validation timing.

/** Controls when field errors are presented without changing validation timing. */
export type VireoFormErrorDisplay = "always" | "never" | "touched-or-submitted" | VireoFormErrorDisplayPredicate;

export type VireoFormErrorDisplayPredicate = (context: {
    submissionAttempts: number;
    touched: boolean;
}) => boolean;

Converts a validation error into consumer-facing helper text.

/** Converts a validation error into consumer-facing helper text. */
export type VireoFormErrorFormatter = (error: unknown) => string | undefined;

Valid keys for VireoFormErrorSummary utility classes and theme style overrides.

/** Valid keys for VireoFormErrorSummary utility classes and theme style overrides. */
export type VireoFormErrorSummaryClassKey = keyof VireoFormErrorSummaryClasses;

Utility classes available to VireoFormErrorSummary.

/** Utility classes available to VireoFormErrorSummary. */
export type VireoFormErrorSummaryClasses = Record<VireoFormErrorSummarySlotName, string>;

export interface VireoFormErrorSummaryContentSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormErrorSummaryGroupLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormErrorSummaryGroupSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormErrorSummaryIconSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormErrorSummaryInheritedProps = Omit<AlertProps, "children" | "icon" | "ref" | "severity" | "slotProps" | "slots" | "title">;

export interface VireoFormErrorSummaryItemButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormErrorSummaryItemSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormErrorSummaryListSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormErrorSummaryLocaleText = {
    title: (context: {
        count: number;
    }) => string;
    formGroupLabel: string;
    otherGroupLabel: string;
    navigateToError: (context: {
        message: string;
    }) => string;
};

export type VireoFormErrorSummaryOwnProps = VireoFormErrorSummarySlotsAndSlotProps & {
    classes?: Partial<VireoFormErrorSummaryClasses>;
    localeText?: Partial<VireoFormErrorSummaryLocaleText>;
    /** Includes only form-level errors or every field error grouped by step. @default 'form' */
    scope?: VireoFormErrorSummaryScope;
    /** Replaces the generated error-count heading. */
    title?: React.ReactNode;
};

export type VireoFormErrorSummaryOwnerState = {
    errorCount: number;
    scope: VireoFormErrorSummaryScope;
};

export type VireoFormErrorSummaryProps = VireoFormErrorSummaryOwnProps & VireoFormErrorSummaryInheritedProps;

export interface VireoFormErrorSummaryRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormErrorSummaryScope = "form" | "all";

export type VireoFormErrorSummarySlots = {
    [T in VireoFormErrorSummarySlotName]: React.ElementType;
};

export type VireoFormErrorSummarySlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormErrorSummarySlots, {
    /** @default Alert */
    root: SlotProps<typeof Alert, VireoFormErrorSummaryRootSlotPropsOverrides, VireoFormErrorSummaryOwnerState>;
    /** @default 'span' */
    icon: SlotProps<typeof Box, VireoFormErrorSummaryIconSlotPropsOverrides, VireoFormErrorSummaryOwnerState>;
    /** @default Box */
    content: SlotProps<typeof Box, VireoFormErrorSummaryContentSlotPropsOverrides, VireoFormErrorSummaryOwnerState>;
    /** @default Typography */
    title: SlotProps<typeof Typography, VireoFormErrorSummaryTitleSlotPropsOverrides, VireoFormErrorSummaryOwnerState>;
    /** @default Box */
    group: SlotProps<typeof Box, VireoFormErrorSummaryGroupSlotPropsOverrides, VireoFormErrorSummaryOwnerState>;
    /** @default Typography */
    groupLabel: SlotProps<typeof Typography, VireoFormErrorSummaryGroupLabelSlotPropsOverrides, VireoFormErrorSummaryOwnerState>;
    /** @default 'ul' */
    list: SlotProps<typeof Box, VireoFormErrorSummaryListSlotPropsOverrides, VireoFormErrorSummaryOwnerState>;
    /** @default 'li' */
    item: SlotProps<typeof Box, VireoFormErrorSummaryItemSlotPropsOverrides, VireoFormErrorSummaryOwnerState>;
    /** @default ButtonBase */
    itemButton: SlotProps<typeof ButtonBase, VireoFormErrorSummaryItemButtonSlotPropsOverrides, VireoFormErrorSummaryOwnerState>;
}>;

export interface VireoFormErrorSummaryTitleSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Valid keys for VireoFormFileField utility classes and theme style overrides.

/** Valid keys for VireoFormFileField utility classes and theme style overrides. */
export type VireoFormFileFieldClassKey = keyof VireoFormFileFieldClasses;

Utility classes available to VireoFormFileField.

/** Utility classes available to VireoFormFileField. */
export type VireoFormFileFieldClasses = Record<VireoFormFileFieldSlotName | "empty" | "populated" | "dragActive" | "dragReject" | "rejected" | "invalid" | "disabled" | "readOnly", string>;

export interface VireoFormFileFieldClearButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileFieldDropOverlaySlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileFieldFileNameSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileFieldFileSizeSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileFieldHelperTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoFormFileField inherits from its default root after excluding component-owned props.

/** Props VireoFormFileField inherits from its default root after excluding component-owned props. */
export type VireoFormFileFieldInheritedProps = Omit<BoxProps<"div">, "children" | "component" | "onChange" | "onDragEnter" | "onDragLeave" | "onDragOver" | "onDrop">;

export interface VireoFormFileFieldInputSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileFieldMetadataSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormFileFieldOwnProps = VireoFormFileFieldSlotsAndSlotProps & {
    /** Native file-accept filter. Exact MIME types, MIME wildcards, and extensions are enforced for picker and drop selection. */
    accept?: string;
    /** Native camera or microphone capture hint. */
    capture?: boolean | "user" | "environment";
    /** Content of the selection action while the value is empty. @default 'Choose file' */
    chooseFileLabel?: React.ReactNode;
    /** Override or extend the utility classes applied to each slot and state. */
    classes?: Partial<VireoFormFileFieldClasses>;
    /** Whether a selected file can be cleared. @default true */
    clearable?: boolean;
    /** Accessible label for the clear action. @default 'Clear selected file' */
    clearFileLabel?: string;
    disabled?: boolean;
    /** Disables drag-and-drop selection while preserving the picker action. @default false */
    disableDrop?: boolean;
    /** Content shown over the field while an acceptable file is dragged across it. @default 'Drop file here' */
    dropActiveText?: React.ReactNode;
    /** Metadata text shown while the bound value is null. @default 'No file selected' */
    emptyText?: React.ReactNode;
    /** Adds an error presentation state without suppressing validation or rejection errors. */
    error?: boolean;
    /** Overrides the enclosing form's error-display policy for this field. */
    errorDisplay?: VireoFormErrorDisplay;
    /** Responsive filename-overflow strategy. @default 'middle' */
    fileNameTruncation?: VireoFormFileNameTruncation;
    /** Message shown when an otherwise accepted file exceeds `maxSize`. */
    fileTooLargeText?: React.ReactNode | ((file: File, maxSize: number) => React.ReactNode);
    /** Overrides the enclosing form's validation-error formatter for this field. */
    formatError?: VireoFormErrorFormatter;
    /** Formats the selected file's byte size. Uses decimal units by default. */
    formatFileSize?: (bytes: number) => React.ReactNode;
    /** Shown when neither a local rejection nor a visible form error takes precedence. Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    /** Hides selected-file size metadata. @default false */
    hideFileSize?: boolean;
    /** Ref forwarded to the hidden native file input. */
    inputRef?: React.Ref<HTMLInputElement>;
    /** Maximum accepted file size in bytes. */
    maxSize?: number;
    /** Observes a locally rejected file after type or size checks. */
    onFileRejected?: (rejection: VireoFileRejection) => void;
    /** Opt-in renderer placed on a dedicated row beneath selected-file metadata. */
    previewRenderer?: VireoFilePreviewRenderer;
    /** Prevents picker, drop, and clear changes while retaining normal presentation. */
    readOnly?: boolean;
    readOnlyEmptyValue?: React.ReactNode;
    renderReadOnlyValue?: (file: File) => React.ReactNode;
    /** Content of the selection action while a value exists. @default 'Replace file' */
    replaceFileLabel?: React.ReactNode;
    /** Adds native required semantics; validation remains owned by TanStack Form or the supplied schema. */
    required?: boolean;
    /** Message shown when a file does not match `accept`. @default 'This file type is not accepted.' */
    unsupportedTypeText?: React.ReactNode | ((file: File) => React.ReactNode);
};

export type VireoFormFileFieldOwnerState = {
    disabled: boolean;
    dragActive: boolean;
    dragReject: boolean;
    empty: boolean;
    errorVisible: boolean;
    invalid: boolean;
    populated: boolean;
    readOnly: boolean;
    rejected: boolean;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
};

export interface VireoFormFileFieldPreviewContainerSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props accepted by `field.FileField`.

/** Props accepted by `field.FileField`. */
export type VireoFormFileFieldProps = VireoFormFileFieldOwnProps & VireoFormFileFieldInheritedProps;

export interface VireoFormFileFieldRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileFieldSelectButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileFieldSelectionSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormFileFieldSlots = {
    [TSlotName in VireoFormFileFieldSlotName]: React.ElementType;
};

export type VireoFormFileFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormFileFieldSlots, {
    /** @default Box */
    root: SlotProps<typeof Box, VireoFormFileFieldRootSlotPropsOverrides, VireoFormFileFieldOwnerState>;
    /** @default Box */
    selection: SlotProps<typeof Box, VireoFormFileFieldSelectionSlotPropsOverrides, VireoFormFileFieldOwnerState>;
    /** @default 'input' */
    input: SlotProps<"input", VireoFormFileFieldInputSlotPropsOverrides, VireoFormFileFieldOwnerState>;
    /** @default Button */
    selectButton: SlotProps<typeof Button, VireoFormFileFieldSelectButtonSlotPropsOverrides, VireoFormFileFieldOwnerState>;
    /** @default Box */
    metadata: SlotProps<typeof Box, VireoFormFileFieldMetadataSlotPropsOverrides, VireoFormFileFieldOwnerState>;
    /** @default Typography */
    fileName: SlotProps<typeof Typography, VireoFormFileFieldFileNameSlotPropsOverrides, VireoFormFileFieldOwnerState>;
    /** @default Typography */
    fileSize: SlotProps<typeof Typography, VireoFormFileFieldFileSizeSlotPropsOverrides, VireoFormFileFieldOwnerState>;
    /** @default IconButton */
    clearButton: SlotProps<typeof IconButton, VireoFormFileFieldClearButtonSlotPropsOverrides, VireoFormFileFieldOwnerState>;
    /** @default Box */
    dropOverlay: SlotProps<typeof Box, VireoFormFileFieldDropOverlaySlotPropsOverrides, VireoFormFileFieldOwnerState>;
    /** @default Box */
    previewContainer: SlotProps<typeof Box, VireoFormFileFieldPreviewContainerSlotPropsOverrides, VireoFormFileFieldOwnerState>;
    /** @default FormHelperText */
    helperText: SlotProps<typeof FormHelperText, VireoFormFileFieldHelperTextSlotPropsOverrides, VireoFormFileFieldOwnerState>;
}>;

export interface VireoFormFileListFieldCapacityTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileListFieldChooserSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Valid keys for VireoFormFileListField utility classes and theme style overrides.

/** Valid keys for VireoFormFileListField utility classes and theme style overrides. */
export type VireoFormFileListFieldClassKey = keyof VireoFormFileListFieldClasses;

Utility classes available to VireoFormFileListField.

/** Utility classes available to VireoFormFileListField. */
export type VireoFormFileListFieldClasses = Record<VireoFormFileListFieldSlotName | VireoFormFileListFieldStateClass, string>;

export interface VireoFormFileListFieldClearAllButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileListFieldDropHintSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileListFieldFileCountSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileListFieldFileNameSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileListFieldFileRowSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileListFieldFileSizeSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileListFieldHelperTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoFormFileListField inherits from its default root after excluding component-owned props.

/** Props VireoFormFileListField inherits from its default root after excluding component-owned props. */
export type VireoFormFileListFieldInheritedProps = Omit<BoxProps<"div">, "children" | "component" | "onChange" | "onDragEnter" | "onDragLeave" | "onDragOver" | "onDrop">;

export interface VireoFormFileListFieldInputSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileListFieldListSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileListFieldLiveRegionSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileListFieldMetadataSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormFileListFieldOwnProps = VireoFormFileListFieldSlotsAndSlotProps & {
    /** Native file-accept filter enforced for picker and drop selection. */
    accept?: string;
    /** Content of the selection action after files exist. @default 'Add more files' */
    addMoreFilesLabel?: React.ReactNode;
    /** Allows files with the same resolved identity. @default false */
    allowDuplicates?: boolean;
    /** Native camera or microphone capture hint. */
    capture?: boolean | "user" | "environment";
    /** Content shown when additions are unavailable because capacity is exhausted. */
    capacityReachedText?: React.ReactNode | ((reason: VireoFileListCapacityReason, limit: number) => React.ReactNode);
    /** Content of the selection action while the collection is empty. @default 'Choose files' */
    chooseFilesLabel?: React.ReactNode;
    /** Override or extend the utility classes applied to each slot and state. */
    classes?: Partial<VireoFormFileListFieldClasses>;
    /** Whether selected files can be removed. @default true */
    clearable?: boolean;
    /** Visible clear-all action content. @default 'Clear all' */
    clearAllLabel?: React.ReactNode;
    /** Accessible label for clear-all. @default 'Clear all selected files' */
    clearAllFilesLabel?: string;
    disabled?: boolean;
    /** Disables external drag-and-drop selection while preserving the picker. @default false */
    disableDrop?: boolean;
    /** Content shown while acceptable files are dragged over the chooser. @default 'Drop files here' */
    dropActiveText?: React.ReactNode;
    /** Persistent guidance shown in the chooser. @default 'or drag and drop files here' */
    dropHint?: React.ReactNode;
    /** Adds an error presentation state without suppressing validation or rejection errors. */
    error?: boolean;
    /** Overrides the enclosing form's error-display policy for this field. */
    errorDisplay?: VireoFormErrorDisplay;
    /** Responsive filename-overflow strategy. @default 'middle' */
    fileNameTruncation?: VireoFormFileNameTruncation;
    /** Describes one file's position to assistive technology. */
    filePositionText?: (file: File, index: number, count: number) => string;
    /** Message shown when an otherwise accepted file exceeds `maxSize`. */
    fileTooLargeText?: React.ReactNode | ((file: File, maxSize: number) => React.ReactNode);
    /** Overrides the enclosing form's validation-error formatter for this field. */
    formatError?: VireoFormErrorFormatter;
    /** Formats the compact collection count. */
    formatFileCount?: (count: number, maxFiles: number | undefined) => React.ReactNode;
    /** Formats individual and total byte sizes. Uses decimal units by default. */
    formatFileSize?: (bytes: number) => React.ReactNode;
    /** Resolves duplicate identity. Defaults to name, size, lastModified, and type. */
    getFileKey?: (file: File) => string;
    /** Shown beneath local rejections and the list. Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    /** Hides the clear-all action. @default false */
    hideClearAll?: boolean;
    /** Hides per-file size metadata. @default false */
    hideFileSize?: boolean;
    /** Ref forwarded to the hidden native file input. */
    inputRef?: React.Ref<HTMLInputElement>;
    /** Maximum number of accepted files. */
    maxFiles?: number;
    /** Message shown for a candidate beyond `maxFiles`. */
    maxFilesText?: React.ReactNode | ((file: File, maxFiles: number) => React.ReactNode);
    /** Maximum accepted size of one file in bytes. */
    maxSize?: number;
    /** Maximum accepted aggregate size in bytes. */
    maxTotalSize?: number;
    /** Message shown when a candidate would exceed `maxTotalSize`. */
    maxTotalSizeText?: React.ReactNode | ((file: File, maxTotalSize: number) => React.ReactNode);
    /** Message shown when a candidate duplicates another selected file. */
    duplicateFileText?: React.ReactNode | ((file: File) => React.ReactNode);
    /** Observes files accepted from one picker or drop operation. */
    onFilesAdded?: (addedFiles: readonly File[], nextFiles: readonly File[]) => void;
    /** Observes files cleared together. */
    onFilesCleared?: (files: readonly File[]) => void;
    /** Observes all candidates rejected by one picker or drop operation. */
    onFilesRejected?: (rejections: readonly VireoFileListRejection[]) => void;
    /** Observes one removed file. */
    onFileRemoved?: (file: File, index: number) => void;
    /** Opt-in renderer placed on a dedicated row beneath each file's metadata. */
    previewRenderer?: VireoFilePreviewRenderer;
    /** Prevents picker, drop, removal, clear-all, and reordering while retaining normal presentation. */
    readOnly?: boolean;
    readOnlyEmptyValue?: React.ReactNode;
    renderReadOnlyValue?: (files: readonly File[]) => React.ReactNode;
    /** Accessible label for one reorder handle. */
    reorderFileLabel?: (file: File, index: number, count: number) => string;
    /** Announcement emitted after a successful reorder. */
    reorderAnnouncement?: (file: File, previousIndex: number, nextIndex: number, count: number) => string;
    /** Enables pointer and keyboard reordering. @default false */
    reorderable?: boolean;
    /** Accessible label for one remove action. */
    removeFileLabel?: (file: File, index: number) => string;
    /** Marks the collection as required for presentation and accessibility. */
    required?: boolean;
    /** Controls whether the root fills its containing width. @default true */
    fullWidth?: boolean;
    /** Message shown when a candidate does not match `accept`. */
    unsupportedTypeText?: React.ReactNode | ((file: File) => React.ReactNode);
};

export type VireoFormFileListFieldOwnerState = {
    capacityReached: boolean;
    clearable: boolean;
    disabled: boolean;
    dragActive: boolean;
    dragReject: boolean;
    dropDisabled: boolean;
    empty: boolean;
    errorVisible: boolean;
    fileCount: number;
    fullWidth: boolean;
    invalid: boolean;
    maxFiles: number | undefined;
    maxTotalSize: number | undefined;
    populated: boolean;
    readOnly: boolean;
    rejected: boolean;
    reordering: boolean;
    reorderable: boolean;
    required: boolean;
    submitting: boolean;
    totalSize: number;
    touched: boolean;
    validating: boolean;
};

export interface VireoFormFileListFieldPreviewContainerSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props accepted by `field.FileListField`.

/** Props accepted by `field.FileListField`. */
export type VireoFormFileListFieldProps = VireoFormFileListFieldOwnProps & VireoFormFileListFieldInheritedProps;

export interface VireoFormFileListFieldRejectionItemSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileListFieldRejectionListSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormFileListFieldRejectionOwnerState = VireoFormFileListFieldOwnerState & {
    index: number;
    rejection: VireoFileListRejection;
};

export interface VireoFormFileListFieldRemoveButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileListFieldReorderHandleSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormFileListFieldRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormFileListFieldRowOwnerState = VireoFormFileListFieldOwnerState & {
    count: number;
    dragging: boolean;
    file: File;
    first: boolean;
    index: number;
    last: boolean;
    previewed: boolean;
};

export interface VireoFormFileListFieldSelectButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormFileListFieldSlots = {
    [TSlotName in VireoFormFileListFieldSlotName]: React.ElementType;
};

export type VireoFormFileListFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormFileListFieldSlots, {
    /** @default Box */
    root: SlotProps<typeof Box, VireoFormFileListFieldRootSlotPropsOverrides, VireoFormFileListFieldOwnerState>;
    /** @default 'input' */
    input: SlotProps<"input", VireoFormFileListFieldInputSlotPropsOverrides, VireoFormFileListFieldOwnerState>;
    /** @default Box */
    chooser: SlotProps<typeof Box, VireoFormFileListFieldChooserSlotPropsOverrides, VireoFormFileListFieldOwnerState>;
    /** @default Button */
    selectButton: SlotProps<typeof Button, VireoFormFileListFieldSelectButtonSlotPropsOverrides, VireoFormFileListFieldOwnerState>;
    /** @default Typography */
    dropHint: SlotProps<typeof Typography, VireoFormFileListFieldDropHintSlotPropsOverrides, VireoFormFileListFieldOwnerState>;
    /** @default Typography */
    capacityText: SlotProps<typeof Typography, VireoFormFileListFieldCapacityTextSlotPropsOverrides, VireoFormFileListFieldOwnerState>;
    /** @default Box */
    toolbar: SlotProps<typeof Box, VireoFormFileListFieldToolbarSlotPropsOverrides, VireoFormFileListFieldOwnerState>;
    /** @default Typography */
    fileCount: SlotProps<typeof Typography, VireoFormFileListFieldFileCountSlotPropsOverrides, VireoFormFileListFieldOwnerState>;
    /** @default Button */
    clearAllButton: SlotProps<typeof Button, VireoFormFileListFieldClearAllButtonSlotPropsOverrides, VireoFormFileListFieldOwnerState>;
    /** @default Box */
    list: SlotProps<typeof Box, VireoFormFileListFieldListSlotPropsOverrides, VireoFormFileListFieldOwnerState>;
    /** @default Box */
    fileRow: SlotProps<typeof Box, VireoFormFileListFieldFileRowSlotPropsOverrides, VireoFormFileListFieldRowOwnerState>;
    /** @default IconButton */
    reorderHandle: SlotProps<typeof IconButton, VireoFormFileListFieldReorderHandleSlotPropsOverrides, VireoFormFileListFieldRowOwnerState>;
    /** @default Box */
    metadata: SlotProps<typeof Box, VireoFormFileListFieldMetadataSlotPropsOverrides, VireoFormFileListFieldRowOwnerState>;
    /** @default Typography */
    fileName: SlotProps<typeof Typography, VireoFormFileListFieldFileNameSlotPropsOverrides, VireoFormFileListFieldRowOwnerState>;
    /** @default Typography */
    fileSize: SlotProps<typeof Typography, VireoFormFileListFieldFileSizeSlotPropsOverrides, VireoFormFileListFieldRowOwnerState>;
    /** @default IconButton */
    removeButton: SlotProps<typeof IconButton, VireoFormFileListFieldRemoveButtonSlotPropsOverrides, VireoFormFileListFieldRowOwnerState>;
    /** @default Box */
    previewContainer: SlotProps<typeof Box, VireoFormFileListFieldPreviewContainerSlotPropsOverrides, VireoFormFileListFieldRowOwnerState>;
    /** @default Box */
    rejectionList: SlotProps<typeof Box, VireoFormFileListFieldRejectionListSlotPropsOverrides, VireoFormFileListFieldOwnerState>;
    /** @default Typography */
    rejectionItem: SlotProps<typeof Typography, VireoFormFileListFieldRejectionItemSlotPropsOverrides, VireoFormFileListFieldRejectionOwnerState>;
    /** @default FormHelperText */
    helperText: SlotProps<typeof FormHelperText, VireoFormFileListFieldHelperTextSlotPropsOverrides, VireoFormFileListFieldOwnerState>;
    /** @default Typography */
    liveRegion: SlotProps<typeof Typography, VireoFormFileListFieldLiveRegionSlotPropsOverrides, VireoFormFileListFieldOwnerState>;
}>;

export type VireoFormFileListFieldStateClass = "empty" | "populated" | "dragActive" | "dragReject" | "rejected" | "invalid" | "disabled" | "readOnly" | "required" | "fullWidth" | "reorderable" | "capacityReached" | "reordering" | "submitting" | "validating";

export interface VireoFormFileListFieldToolbarSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Responsive filename-overflow strategies shared by Vireo file fields.

/** Responsive filename-overflow strategies shared by Vireo file fields. */
export type VireoFormFileNameTruncation = "middle" | "end" | "none";

Valid keys for VireoFormFreeSoloAutocompleteField utility classes and theme style overrides.

/** Valid keys for VireoFormFreeSoloAutocompleteField utility classes and theme style overrides. */
export type VireoFormFreeSoloAutocompleteFieldClassKey = keyof VireoFormFreeSoloAutocompleteFieldClasses;

Utility classes available to VireoFormFreeSoloAutocompleteField.

/** Utility classes available to VireoFormFreeSoloAutocompleteField. */
export type VireoFormFreeSoloAutocompleteFieldClasses = Record<VireoFormFreeSoloAutocompleteFieldSlotName | VireoFormFreeSoloAutocompleteFieldStateName, string>;

export type VireoFormFreeSoloAutocompleteFieldFilterState = {
    inputValue: string;
};

export type VireoFormFreeSoloAutocompleteFieldInheritedProps<TOption> = Omit<AutocompleteProps<TOption, false, false, true>, OwnedAutocompleteProp>;

export type VireoFormFreeSoloAutocompleteFieldInputChangeReason = "input" | "reset" | "clear" | "blur" | "selectOption" | "removeOption";

export type VireoFormFreeSoloAutocompleteFieldOwnProps<TOption> = VireoFormFreeSoloAutocompleteFieldSlotsAndSlotProps & FilterContract<TOption> & {
    label: React.ReactNode;
    options: readonly TOption[];
    getOptionValue: (option: TOption) => string;
    getOptionLabel: (option: TOption) => string;
    getOptionDisabled?: (option: TOption) => boolean;
    renderOption?: (option: TOption, state: VireoFormFreeSoloAutocompleteFieldRenderOptionState) => React.ReactNode;
    createOptionLabel?: (value: string) => React.ReactNode;
    normalizeValue?: (value: string) => string;
    isValueEqual?: (left: string, right: string) => boolean;
    commitOnBlur?: boolean;
    groupBy?: (option: TOption) => string;
    renderGroupLabel?: (group: string) => React.ReactNode;
    classes?: Partial<VireoFormFreeSoloAutocompleteFieldClasses>;
    disabled?: boolean;
    readOnly?: boolean;
    readOnlyEmptyValue?: React.ReactNode;
    renderReadOnlyValue?: (value: string, selection: VireoFormFreeSoloAutocompleteFieldSelection<TOption>) => React.ReactNode;
    required?: boolean;
    error?: boolean;
    errorDisplay?: VireoFormErrorDisplay;
    formatError?: VireoFormErrorFormatter;
    /** Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    fullWidth?: boolean;
    placeholder?: string;
    variant?: TextFieldProps["variant"];
    size?: TextFieldProps["size"];
    color?: TextFieldProps["color"];
    margin?: TextFieldProps["margin"];
    inputRef?: React.Ref<HTMLInputElement>;
    inputValue?: string;
    defaultInputValue?: string;
    onBlur?: React.FocusEventHandler<HTMLInputElement>;
    onInputValueChange?: (value: string, reason: VireoFormFreeSoloAutocompleteFieldInputChangeReason) => void;
    onValueChange?: (value: string | null, details: VireoFormFreeSoloAutocompleteFieldValueChangeDetails<TOption>) => void;
    loading?: boolean;
    loadingText?: React.ReactNode;
    noOptionsText?: React.ReactNode;
    disableClearable?: boolean;
    clearOnEscape?: boolean;
    clearLabel?: string;
    openLabel?: string;
    closeLabel?: string;
    open?: boolean;
    defaultOpen?: boolean;
    onOpen?: () => void;
    onClose?: NonNullable<AutocompleteProps<TOption, false, false, true>["onClose"]>;
    clearIcon?: React.ReactNode;
    popupIcon?: React.ReactNode;
};

export type VireoFormFreeSoloAutocompleteFieldOwnerState = {
    dirty: boolean;
    disabled: boolean;
    error: boolean;
    focused: boolean;
    hasInputValue: boolean;
    hasValue: boolean;
    loading: boolean;
    open: boolean;
    readOnly: boolean;
    required: boolean;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
};

export type VireoFormFreeSoloAutocompleteFieldProps<TOption = string> = VireoFormFreeSoloAutocompleteFieldOwnProps<TOption> & VireoFormFreeSoloAutocompleteFieldInheritedProps<TOption>;

export type VireoFormFreeSoloAutocompleteFieldRenderOptionState = {
    inputValue: string;
    selected: boolean;
    disabled: boolean;
    index: number;
};

export type VireoFormFreeSoloAutocompleteFieldSelection<TOption> = {
    value: string;
    label: string;
    custom: boolean;
    option: TOption | null;
};

export interface VireoFormFreeSoloAutocompleteFieldSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormFreeSoloAutocompleteFieldSlots = {
    root: React.ElementType;
    textField: React.ElementType;
    inputLabel: React.ElementType;
    input: React.ElementType;
    htmlInput: React.ElementType;
    loadingIndicator: React.ElementType;
    clearButton: React.ElementType;
    clearIcon: React.ElementType;
    popupButton: React.ElementType;
    popupIcon: React.ElementType;
    formHelperText: React.ElementType;
    popper: React.ElementType;
    paper: React.ElementType;
    loadingText: React.ElementType;
    noOptionsText: React.ElementType;
    listbox: React.ElementType;
    option: React.ElementType;
    group: React.ElementType;
    groupLabel: React.ElementType;
    groupList: React.ElementType;
};

export type VireoFormFreeSoloAutocompleteFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormFreeSoloAutocompleteFieldSlots, {
    root: CommonSlotProps<typeof Box>;
    textField: CommonSlotProps<typeof TextField>;
    inputLabel: CommonSlotProps<typeof InputLabel>;
    input: CommonSlotProps<"div">;
    htmlInput: CommonSlotProps<"input">;
    loadingIndicator: CommonSlotProps<typeof CircularProgress>;
    clearButton: CommonSlotProps<typeof IconButton>;
    clearIcon: CommonSlotProps<"svg">;
    popupButton: CommonSlotProps<typeof IconButton>;
    popupIcon: CommonSlotProps<"svg">;
    formHelperText: CommonSlotProps<typeof FormHelperText>;
    popper: CommonSlotProps<typeof Popper>;
    paper: CommonSlotProps<typeof Paper>;
    loadingText: CommonSlotProps<"div">;
    noOptionsText: CommonSlotProps<"div">;
    listbox: CommonSlotProps<"ul">;
    option: CommonSlotProps<"li">;
    group: CommonSlotProps<"li">;
    groupLabel: CommonSlotProps<typeof ListSubheader>;
    groupList: CommonSlotProps<"ul">;
}>;

export type VireoFormFreeSoloAutocompleteFieldValueChangeDetails<TOption> = {
    reason: "selectOption";
    option: TOption;
    value: string;
} | {
    reason: "createOption";
    value: string;
} | {
    reason: "clear";
    previousValue: string | null;
};

Valid keys for VireoFormFreeSoloAutocompleteMultipleField utility classes and theme style overrides.

/** Valid keys for VireoFormFreeSoloAutocompleteMultipleField utility classes and theme style overrides. */
export type VireoFormFreeSoloAutocompleteMultipleFieldClassKey = keyof VireoFormFreeSoloAutocompleteMultipleFieldClasses;

Utility classes available to VireoFormFreeSoloAutocompleteMultipleField.

/** Utility classes available to VireoFormFreeSoloAutocompleteMultipleField. */
export type VireoFormFreeSoloAutocompleteMultipleFieldClasses = Record<VireoFormFreeSoloAutocompleteMultipleFieldSlotName | VireoFormFreeSoloAutocompleteMultipleFieldStateName, string>;

export type VireoFormFreeSoloAutocompleteMultipleFieldFilterState = {
    inputValue: string;
};

export type VireoFormFreeSoloAutocompleteMultipleFieldInheritedProps<TOption> = Omit<AutocompleteProps<TOption, true, false, true>, OwnedAutocompleteProp>;

export type VireoFormFreeSoloAutocompleteMultipleFieldInputChangeReason = "input" | "reset" | "clear" | "blur" | "selectOption" | "removeOption";

export type VireoFormFreeSoloAutocompleteMultipleFieldOwnProps<TOption> = VireoFormFreeSoloAutocompleteMultipleFieldSlotsAndSlotProps & FilterContract<TOption> & {
    label: React.ReactNode;
    options: readonly TOption[];
    getOptionValue: (option: TOption) => string;
    getOptionLabel: (option: TOption) => string;
    getOptionDisabled?: (option: TOption) => boolean;
    renderOption?: (option: TOption, state: VireoFormFreeSoloAutocompleteMultipleFieldRenderOptionState) => React.ReactNode;
    createOptionLabel?: (value: string) => React.ReactNode;
    normalizeValue?: (value: string) => string;
    isValueEqual?: (left: string, right: string) => boolean;
    commitOnBlur?: boolean;
    groupBy?: (option: TOption) => string;
    renderGroupLabel?: (group: string) => React.ReactNode;
    renderSelectedOptions?: (params: VireoFormFreeSoloAutocompleteMultipleFieldRenderSelectedOptionsParams<TOption>) => React.ReactNode;
    maxDisplayedOptions?: number;
    maxSelectedOptions?: number;
    getHiddenOptionsText?: (count: number) => React.ReactNode;
    getHiddenOptionsLabel?: (count: number) => string;
    getRemoveOptionLabel?: (selection: VireoFormFreeSoloAutocompleteMultipleFieldSelection<TOption>) => string;
    hideOptionCheckbox?: boolean;
    removeOnBackspace?: boolean;
    classes?: Partial<VireoFormFreeSoloAutocompleteMultipleFieldClasses>;
    disabled?: boolean;
    readOnly?: boolean;
    readOnlyEmptyValue?: React.ReactNode;
    renderReadOnlyValue?: (values: readonly string[], selections: readonly VireoFormFreeSoloAutocompleteMultipleFieldSelection<TOption>[]) => React.ReactNode;
    required?: boolean;
    error?: boolean;
    errorDisplay?: VireoFormErrorDisplay;
    formatError?: VireoFormErrorFormatter;
    /** Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    fullWidth?: boolean;
    placeholder?: string;
    variant?: TextFieldProps["variant"];
    size?: TextFieldProps["size"];
    color?: TextFieldProps["color"];
    margin?: TextFieldProps["margin"];
    inputRef?: React.Ref<HTMLInputElement>;
    inputValue?: string;
    defaultInputValue?: string;
    onBlur?: React.FocusEventHandler<HTMLInputElement>;
    onInputValueChange?: (value: string, reason: VireoFormFreeSoloAutocompleteMultipleFieldInputChangeReason) => void;
    onValueChange?: (value: string[], details: VireoFormFreeSoloAutocompleteMultipleFieldValueChangeDetails<TOption>) => void;
    loading?: boolean;
    loadingText?: React.ReactNode;
    noOptionsText?: React.ReactNode;
    disableClearable?: boolean;
    clearOnEscape?: boolean;
    clearLabel?: string;
    openLabel?: string;
    closeLabel?: string;
    open?: boolean;
    defaultOpen?: boolean;
    onOpen?: () => void;
    onClose?: NonNullable<AutocompleteProps<TOption, true, false, true>["onClose"]>;
    clearIcon?: React.ReactNode;
    popupIcon?: React.ReactNode;
};

export type VireoFormFreeSoloAutocompleteMultipleFieldOwnerState = {
    dirty: boolean;
    disabled: boolean;
    error: boolean;
    focused: boolean;
    hasInputValue: boolean;
    hasValue: boolean;
    loading: boolean;
    open: boolean;
    readOnly: boolean;
    required: boolean;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
    atSelectionLimit: boolean;
    hasHiddenOptions: boolean;
};

export type VireoFormFreeSoloAutocompleteMultipleFieldProps<TOption = string> = VireoFormFreeSoloAutocompleteMultipleFieldOwnProps<TOption> & VireoFormFreeSoloAutocompleteMultipleFieldInheritedProps<TOption>;

export type VireoFormFreeSoloAutocompleteMultipleFieldRenderOptionState = {
    inputValue: string;
    selected: boolean;
    disabled: boolean;
    index: number;
};

export type VireoFormFreeSoloAutocompleteMultipleFieldRenderSelectedOptionsParams<TOption> = {
    selections: readonly VireoFormFreeSoloAutocompleteMultipleFieldSelection<TOption>[];
    displayedSelections: readonly VireoFormFreeSoloAutocompleteMultipleFieldSelection<TOption>[];
    hiddenCount: number;
    maxDisplayedOptions: number;
    getRemoveButtonProps: (value: string) => {
        "aria-label": string;
        disabled: boolean;
        onClick: React.MouseEventHandler<HTMLButtonElement>;
    };
};

export type VireoFormFreeSoloAutocompleteMultipleFieldSelection<TOption> = {
    value: string;
    label: string;
    custom: boolean;
    option: TOption | null;
};

export interface VireoFormFreeSoloAutocompleteMultipleFieldSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormFreeSoloAutocompleteMultipleFieldSlots = {
    root: React.ElementType;
    textField: React.ElementType;
    inputLabel: React.ElementType;
    input: React.ElementType;
    htmlInput: React.ElementType;
    loadingIndicator: React.ElementType;
    clearButton: React.ElementType;
    clearIcon: React.ElementType;
    popupButton: React.ElementType;
    popupIcon: React.ElementType;
    formHelperText: React.ElementType;
    popper: React.ElementType;
    paper: React.ElementType;
    loadingText: React.ElementType;
    noOptionsText: React.ElementType;
    listbox: React.ElementType;
    option: React.ElementType;
    group: React.ElementType;
    groupLabel: React.ElementType;
    groupList: React.ElementType;
    selectedOptions: React.ElementType;
    selectedOption: React.ElementType;
    selectedOptionDeleteIcon: React.ElementType;
    hiddenOptionsButton: React.ElementType;
    optionCheckbox: React.ElementType;
};

export type VireoFormFreeSoloAutocompleteMultipleFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormFreeSoloAutocompleteMultipleFieldSlots, {
    root: CommonSlotProps<typeof Box>;
    textField: CommonSlotProps<typeof TextField>;
    inputLabel: CommonSlotProps<typeof InputLabel>;
    input: CommonSlotProps<"div">;
    htmlInput: CommonSlotProps<"input">;
    loadingIndicator: CommonSlotProps<typeof CircularProgress>;
    clearButton: CommonSlotProps<typeof IconButton>;
    clearIcon: CommonSlotProps<"svg">;
    popupButton: CommonSlotProps<typeof IconButton>;
    popupIcon: CommonSlotProps<"svg">;
    formHelperText: CommonSlotProps<typeof FormHelperText>;
    popper: CommonSlotProps<typeof Popper>;
    paper: CommonSlotProps<typeof Paper>;
    loadingText: CommonSlotProps<"div">;
    noOptionsText: CommonSlotProps<"div">;
    listbox: CommonSlotProps<"ul">;
    option: CommonSlotProps<"li">;
    group: CommonSlotProps<"li">;
    groupLabel: CommonSlotProps<typeof ListSubheader>;
    groupList: CommonSlotProps<"ul">;
    selectedOptions: CommonSlotProps<"div">;
    selectedOption: CommonSlotProps<typeof Chip>;
    selectedOptionDeleteIcon: CommonSlotProps<"svg">;
    hiddenOptionsButton: CommonSlotProps<typeof Button>;
    optionCheckbox: CommonSlotProps<typeof Checkbox>;
}>;

export type VireoFormFreeSoloAutocompleteMultipleFieldValueChangeDetails<TOption> = {
    reason: "selectOption";
    option: TOption;
    value: string;
} | {
    reason: "createOption";
    value: string;
} | {
    reason: "removeOption";
    option: TOption | null;
    value: string;
} | {
    reason: "clear";
    previousValues: string[];
};

Props VireoForm inherits from its default root after excluding component-owned props.

/** Props VireoForm inherits from its default root after excluding component-owned props. */
export type VireoFormInheritedProps = Omit<React.ComponentPropsWithoutRef<"form">, keyof VireoFormOwnProps | "ref"> & {
    sx?: SxProps<Theme>;
};

Standard content-width presets owned by {@link VireoForm }.

/** Standard content-width presets owned by {@link VireoForm}. */
export type VireoFormLayoutWidth = "standard" | "wide" | "full";

Valid keys for VireoFormMultiStep utility classes and theme style overrides.

/** Valid keys for VireoFormMultiStep utility classes and theme style overrides. */
export type VireoFormMultiStepClassKey = keyof VireoFormMultiStepClasses;

Utility classes available to VireoFormMultiStep.

/** Utility classes available to VireoFormMultiStep. */
export type VireoFormMultiStepClasses = Record<VireoFormMultiStepSlotName, string>;

Props VireoFormMultiStep inherits from its default root after excluding component-owned props.

/** Props VireoFormMultiStep inherits from its default root after excluding component-owned props. */
export type VireoFormMultiStepInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

export type VireoFormMultiStepLocaleText = {
    progressLabel: string;
    previousButton: string;
    nextButton: string;
    stepCount: (context: {
        current: number;
        total: number;
    }) => string;
    currentStatus: string;
    completeStatus: string;
    errorStatus: string;
    visitedStatus: string;
    upcomingStatus: string;
    openStepMenu: (context: {
        label: string;
        current: number;
        total: number;
    }) => string;
};

Props owned by {@link VireoFormMultiStep }.

/** Props owned by {@link VireoFormMultiStep}. */
export type VireoFormMultiStepOwnProps = VireoFormMultiStepSlotsAndSlotProps & {
    children?: React.ReactNode;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoFormMultiStepClasses>;
    /** Keeps applicable inactive steps mounted with the native hidden attribute. @default false */
    keepMounted?: boolean;
    /** Overrides built-in English progress and navigation copy for this multi-step boundary. */
    localeText?: Partial<VireoFormMultiStepLocaleText>;
};

export type VireoFormMultiStepOwnerState = {
    keepMounted: boolean;
};

Props accepted by {@link VireoFormMultiStep }.

/** Props accepted by {@link VireoFormMultiStep}. */
export type VireoFormMultiStepProps = VireoFormMultiStepOwnProps & VireoFormMultiStepInheritedProps;

export interface VireoFormMultiStepRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoFormMultiStep }.

/** Replaceable semantic regions exposed by {@link VireoFormMultiStep}. */
export type VireoFormMultiStepSlots = {
    [TSlotName in VireoFormMultiStepSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoFormMultiStep }.

/** Slot props exposed by {@link VireoFormMultiStep}. */
export type VireoFormMultiStepSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormMultiStepSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoFormMultiStepRootSlotPropsOverrides, VireoFormMultiStepOwnerState>;
}>;

Valid keys for VireoFormNextStepButton utility classes and theme style overrides.

/** Valid keys for VireoFormNextStepButton utility classes and theme style overrides. */
export type VireoFormNextStepButtonClassKey = keyof VireoFormNextStepButtonClasses;

Utility classes available to VireoFormNextStepButton.

/** Utility classes available to VireoFormNextStepButton. */
export type VireoFormNextStepButtonClasses = Record<VireoFormNextStepButtonSlotName | VireoFormNextStepButtonStateName, string>;

export type VireoFormNextStepButtonInheritedProps = Omit<ButtonProps, "component" | "href" | "loading" | "loadingIndicator" | "type">;

export interface VireoFormNextStepButtonLoadingIndicatorSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormNextStepButtonOwnProps = VireoFormNextStepButtonSlotsAndSlotProps & {
    children?: React.ReactNode;
    classes?: Partial<VireoFormNextStepButtonClasses>;
    /** Adds a consumer-owned loading condition to step validation. @default false */
    loading?: boolean | null;
    /** Hides the next action on the final step or leaves it disabled. @default 'auto' */
    visibility?: "auto" | "always";
};

export type VireoFormNextStepButtonOwnerState = {
    disabled: boolean;
    lastStep: boolean;
    loading: boolean;
    visibility: "auto" | "always";
};

export type VireoFormNextStepButtonProps = VireoFormNextStepButtonOwnProps & VireoFormNextStepButtonInheritedProps;

export interface VireoFormNextStepButtonRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormNextStepButtonSlots = {
    [T in VireoFormNextStepButtonSlotName]: React.ElementType;
};

export type VireoFormNextStepButtonSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormNextStepButtonSlots, {
    /** @default Button */
    root: SlotProps<typeof Button, VireoFormNextStepButtonRootSlotPropsOverrides, VireoFormNextStepButtonOwnerState>;
    /** @default CircularProgress */
    loadingIndicator: SlotProps<typeof CircularProgress, VireoFormNextStepButtonLoadingIndicatorSlotPropsOverrides, VireoFormNextStepButtonOwnerState>;
}>;

Valid keys for VireoFormNumberField utility classes and theme style overrides.

/** Valid keys for VireoFormNumberField utility classes and theme style overrides. */
export type VireoFormNumberFieldClassKey = keyof VireoFormNumberFieldClasses;

Utility classes available to VireoFormNumberField.

/** Utility classes available to VireoFormNumberField. */
export type VireoFormNumberFieldClasses = Record<VireoFormNumberFieldSlotName | VireoFormNumberFieldStateName, string>;

export interface VireoFormNumberFieldFormHelperTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormNumberFieldHtmlInputSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props inherited from MUI TextField after excluding form-owned and Vireo-owned props.

/** Props inherited from MUI TextField after excluding form-owned and Vireo-owned props. */
export type VireoFormNumberFieldInheritedProps = Omit<TextFieldProps, VireoFormNumberFieldComponentOwnedProp>;

export interface VireoFormNumberFieldInputLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormNumberFieldInputSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by the bound form number field. The field name and value remain owned by `form.Field`.

/** Props owned by the bound form number field. The field name and value remain owned by `form.Field`. */
export type VireoFormNumberFieldOwnProps = VireoFormNumberFieldSlotsAndSlotProps & {
    /** Override or extend the utility classes applied to each slot and state. */
    classes?: Partial<VireoFormNumberFieldClasses>;
    disabled?: boolean;
    /** Adds an error presentation state without suppressing validation errors. */
    error?: boolean;
    /** Overrides the enclosing form's error-display policy for this field. */
    errorDisplay?: VireoFormErrorDisplay;
    /** Overrides the enclosing form's validation-error formatter for this field. */
    formatError?: VireoFormErrorFormatter;
    /** @default true */
    fullWidth?: boolean;
    /** Shown when no visible validation error takes precedence. Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    /** Ref forwarded to the native input. */
    inputRef?: React.Ref<HTMLInputElement>;
    /** Largest value emitted to the bound field. */
    max?: number;
    /** Smallest value emitted to the bound field. */
    min?: number;
    onBlur?: NonNullable<TextFieldProps["onBlur"]>;
    onChange?: NonNullable<TextFieldProps["onChange"]>;
    readOnly?: boolean;
    readOnlyEmptyValue?: React.ReactNode;
    renderReadOnlyValue?: (value: number) => React.ReactNode;
    required?: boolean;
};

export type VireoFormNumberFieldOwnerState = {
    dirty: boolean;
    disabled: boolean;
    errorVisible: boolean;
    invalid: boolean;
    readOnly: boolean;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
};

Props accepted by `field.NumberField`.

/** Props accepted by `field.NumberField`. */
export type VireoFormNumberFieldProps = VireoFormNumberFieldOwnProps & VireoFormNumberFieldInheritedProps;

export interface VireoFormNumberFieldRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by the bound form number field.

/** Replaceable semantic regions exposed by the bound form number field. */
export type VireoFormNumberFieldSlots = {
    root: React.ElementType;
    inputLabel: React.ElementType;
    input: React.ElementType;
    htmlInput: React.ElementType;
    formHelperText: React.ElementType;
};

Slot props exposed by the bound form number field.

/** Slot props exposed by the bound form number field. */
export type VireoFormNumberFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormNumberFieldSlots, {
    /** @default FormControl */
    root: SlotProps<typeof FormControl, VireoFormNumberFieldRootSlotPropsOverrides, VireoFormNumberFieldOwnerState>;
    /** @default InputLabel */
    inputLabel: SlotProps<typeof InputLabel, VireoFormNumberFieldInputLabelSlotPropsOverrides, VireoFormNumberFieldOwnerState>;
    /** @default OutlinedInput; follows `variant` for standard and filled fields. */
    input: SlotProps<typeof OutlinedInput, VireoFormNumberFieldInputSlotPropsOverrides, VireoFormNumberFieldOwnerState>;
    /** @default 'input' */
    htmlInput: SlotProps<"input", VireoFormNumberFieldHtmlInputSlotPropsOverrides, VireoFormNumberFieldOwnerState>;
    /** @default FormHelperText */
    formHelperText: SlotProps<typeof FormHelperText, VireoFormNumberFieldFormHelperTextSlotPropsOverrides, VireoFormNumberFieldOwnerState>;
}>;

Props owned by {@link VireoForm }.

/** Props owned by {@link VireoForm}. */
export type VireoFormOwnProps = VireoFormSlotsAndSlotProps & {
    children?: React.ReactNode;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoFormClasses>;
    /** Controls when bound fields present validation errors. @default 'touched-or-submitted' */
    errorDisplay?: VireoFormErrorDisplay;
    /** Overrides Vireo's default validation-error formatter for bound fields. */
    formatError?: VireoFormErrorFormatter;
    /** Focuses the first focusable invalid field after a rejected submit. @default true */
    focusInvalidFieldOnSubmit?: boolean;
    /** Constrains and centers the form using Vireo's standard content-width presets. @default 'standard' */
    layoutWidth?: VireoFormLayoutWidth;
    /** Presents every bound field as a non-editable display value and suppresses form submission. @default false */
    readOnly?: boolean;
    /** Fallback shown by read-only fields with no meaningful value. @default 'Not provided' */
    readOnlyEmptyValue?: React.ReactNode;
    /** Registers this form with the unsaved-changes capability while it is dirty. @default false */
    unsavedChangesGuard?: boolean;
    /** Adds non-form busy work to the unsaved-changes registration. @default false */
    unsavedChangesBusy?: boolean;
    /** Overrides the nearest unsaved-changes scope for this form. */
    unsavedChangesScopeId?: string;
};

export type VireoFormOwnerState = {
    dirty: boolean;
    invalid: boolean;
    layoutWidth: VireoFormLayoutWidth;
    readOnly: boolean;
    submitting: boolean;
    validating: boolean;
};

Valid keys for VireoFormPreviousStepButton utility classes and theme style overrides.

/** Valid keys for VireoFormPreviousStepButton utility classes and theme style overrides. */
export type VireoFormPreviousStepButtonClassKey = keyof VireoFormPreviousStepButtonClasses;

Utility classes available to VireoFormPreviousStepButton.

/** Utility classes available to VireoFormPreviousStepButton. */
export type VireoFormPreviousStepButtonClasses = Record<VireoFormPreviousStepButtonSlotName | VireoFormPreviousStepButtonStateName, string>;

export type VireoFormPreviousStepButtonInheritedProps = Omit<ButtonProps, "component" | "href" | "type">;

export type VireoFormPreviousStepButtonOwnProps = VireoFormPreviousStepButtonSlotsAndSlotProps & {
    children?: React.ReactNode;
    classes?: Partial<VireoFormPreviousStepButtonClasses>;
    /** Hides the action on the first step or leaves it disabled. @default 'auto' */
    visibility?: "auto" | "always";
};

export type VireoFormPreviousStepButtonOwnerState = {
    disabled: boolean;
    firstStep: boolean;
    visibility: "auto" | "always";
};

export type VireoFormPreviousStepButtonProps = VireoFormPreviousStepButtonOwnProps & VireoFormPreviousStepButtonInheritedProps;

export interface VireoFormPreviousStepButtonRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormPreviousStepButtonSlots = {
    [T in VireoFormPreviousStepButtonSlotName]: React.ElementType;
};

export type VireoFormPreviousStepButtonSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormPreviousStepButtonSlots, {
    /** @default Button */
    root: SlotProps<typeof Button, VireoFormPreviousStepButtonRootSlotPropsOverrides, VireoFormPreviousStepButtonOwnerState>;
}>;

Props accepted by {@link VireoForm }.

/** Props accepted by {@link VireoForm}. */
export type VireoFormProps = VireoFormOwnProps & VireoFormInheritedProps;

Accessible naming contract for the radio group itself.

/** Accessible naming contract for the radio group itself. */
export type VireoFormRadioGroupFieldAccessibleNameProps = {
    "aria-label": string;
    "aria-labelledby"?: string;
} | {
    "aria-label"?: undefined;
    "aria-labelledby": string;
};

Valid keys for VireoFormRadioGroupField utility classes and theme style overrides.

/** Valid keys for VireoFormRadioGroupField utility classes and theme style overrides. */
export type VireoFormRadioGroupFieldClassKey = keyof VireoFormRadioGroupFieldClasses;

Utility classes available to VireoFormRadioGroupField.

/** Utility classes available to VireoFormRadioGroupField. */
export type VireoFormRadioGroupFieldClasses = Record<VireoFormRadioGroupFieldSlotName | VireoFormRadioGroupFieldStateClassKey, string>;

export interface VireoFormRadioGroupFieldFormControlLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormRadioGroupFieldFormHelperTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoFormRadioGroupField inherits from its default root after excluding component-owned props.

/** Props VireoFormRadioGroupField inherits from its default root after excluding component-owned props. */
export type VireoFormRadioGroupFieldInheritedProps = Omit<FormControlProps, VireoFormRadioGroupFieldComponentOwnedProp>;

export interface VireoFormRadioGroupFieldOptionLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by the bound form radio-group field. The field name and value remain owned by `form.Field`.

/** Props owned by the bound form radio-group field. The field name and value remain owned by `form.Field`. */
export type VireoFormRadioGroupFieldOwnProps<TOption, TValue extends VireoFormRadioGroupFieldValue> = VireoFormRadioGroupFieldSlotsAndSlotProps & {
    /** Options rendered by the group. */
    options: readonly TOption[];
    /** Returns the stable unique scalar value stored by the form for one option. */
    getOptionValue: (option: TOption) => TValue;
    /** Renders the visible label for one option. */
    renderOption: (option: TOption) => React.ReactNode;
    /** Returns whether one option is unavailable. */
    getOptionDisabled?: (option: TOption) => boolean;
    /** Override or extend the utility classes applied to each slot and state. */
    classes?: Partial<VireoFormRadioGroupFieldClasses>;
    disabled?: boolean;
    /** Adds an error presentation state without suppressing validation errors. */
    error?: boolean;
    /** Overrides the enclosing form's error-display policy for this field. */
    errorDisplay?: VireoFormErrorDisplay;
    /** Overrides the enclosing form's validation-error formatter for this field. */
    formatError?: VireoFormErrorFormatter;
    /** @default true */
    fullWidth?: boolean;
    /** Shown when no visible validation error takes precedence. Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    /** Places option controls horizontally. @default false */
    row?: boolean;
    /** @default 'end' */
    labelPlacement?: FormControlLabelProps["labelPlacement"];
    onBlur?: NonNullable<RadioGroupProps["onBlur"]>;
    onChange?: NonNullable<RadioGroupProps["onChange"]>;
    /** Observes accepted option changes after cancelable handlers. */
    onValueChange?: (value: TValue) => void;
    readOnly?: boolean;
    readOnlyEmptyValue?: React.ReactNode;
    renderReadOnlyValue?: (value: TValue, option: TOption | undefined) => React.ReactNode;
    required?: boolean;
    "aria-describedby"?: string;
};

export type VireoFormRadioGroupFieldOwnerState = {
    dirty: boolean;
    disabled: boolean;
    errorVisible: boolean;
    hasValue: boolean;
    invalid: boolean;
    readOnly: boolean;
    row: boolean;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
};

Props accepted by `field.RadioGroupField`.

/** Props accepted by `field.RadioGroupField`. */
export type VireoFormRadioGroupFieldProps<TOption = unknown, TValue extends VireoFormRadioGroupFieldValue = VireoFormRadioGroupFieldValue> = VireoFormRadioGroupFieldOwnProps<TOption, TValue> & VireoFormRadioGroupFieldAccessibleNameProps & VireoFormRadioGroupFieldInheritedProps;

export interface VireoFormRadioGroupFieldRadioGroupSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormRadioGroupFieldRadioSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormRadioGroupFieldRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by the bound form radio-group field.

/** Replaceable semantic regions exposed by the bound form radio-group field. */
export type VireoFormRadioGroupFieldSlots = {
    root: React.ElementType;
    radioGroup: React.ElementType;
    formControlLabel: React.ElementType;
    radio: React.ElementType;
    optionLabel: React.ElementType;
    formHelperText: React.ElementType;
};

Slot props exposed by the bound form radio-group field.

/** Slot props exposed by the bound form radio-group field. */
export type VireoFormRadioGroupFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormRadioGroupFieldSlots, {
    /** @default FormControl */
    root: SlotProps<typeof FormControl, VireoFormRadioGroupFieldRootSlotPropsOverrides, VireoFormRadioGroupFieldOwnerState>;
    /** @default RadioGroup */
    radioGroup: SlotProps<typeof RadioGroup, VireoFormRadioGroupFieldRadioGroupSlotPropsOverrides, VireoFormRadioGroupFieldOwnerState>;
    /** @default FormControlLabel */
    formControlLabel: SlotProps<typeof FormControlLabel, VireoFormRadioGroupFieldFormControlLabelSlotPropsOverrides, VireoFormRadioGroupFieldOwnerState>;
    /** @default Radio */
    radio: SlotProps<typeof Radio, VireoFormRadioGroupFieldRadioSlotPropsOverrides, VireoFormRadioGroupFieldOwnerState>;
    /** @default Typography */
    optionLabel: SlotProps<typeof Typography, VireoFormRadioGroupFieldOptionLabelSlotPropsOverrides, VireoFormRadioGroupFieldOwnerState>;
    /** @default FormHelperText */
    formHelperText: SlotProps<typeof FormHelperText, VireoFormRadioGroupFieldFormHelperTextSlotPropsOverrides, VireoFormRadioGroupFieldOwnerState>;
}>;

Scalar values supported by `field.RadioGroupField`. Objects remain represented by their stable option value.

/** Scalar values supported by `field.RadioGroupField`. Objects remain represented by their stable option value. */
export type VireoFormRadioGroupFieldValue = string | number;

Presents a bound form value as text without editable control chrome.

/**
 * Presents a bound form value as text without editable control chrome.
 */
export declare const VireoFormReadOnlyValue: React.ForwardRefExoticComponent<Omit<VireoFormReadOnlyValueProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoFormReadOnlyValue utility classes and theme style overrides.

/** Valid keys for VireoFormReadOnlyValue utility classes and theme style overrides. */
export type VireoFormReadOnlyValueClassKey = keyof VireoFormReadOnlyValueClasses;

Utility classes available to VireoFormReadOnlyValue.

/** Utility classes available to VireoFormReadOnlyValue. */
export type VireoFormReadOnlyValueClasses = Record<VireoFormReadOnlyValueSlotName | "empty" | "hasLabel", string>;

Props VireoFormReadOnlyValue inherits from its default root after excluding component-owned props.

/** Props VireoFormReadOnlyValue inherits from its default root after excluding component-owned props. */
export type VireoFormReadOnlyValueInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

export interface VireoFormReadOnlyValueLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by {@link VireoFormReadOnlyValue }.

/** Props owned by {@link VireoFormReadOnlyValue}. */
export type VireoFormReadOnlyValueOwnProps = VireoFormReadOnlyValueSlotsAndSlotProps & {
    /** Value content rendered without editable control chrome. */
    children?: React.ReactNode;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoFormReadOnlyValueClasses>;
    /** Whether the bound field has no meaningful value. @default false */
    empty?: boolean;
    /** Content rendered when `empty` is true. @default 'Not provided' */
    emptyValue?: React.ReactNode;
    /** Optional visible field label. Required indicators are intentionally omitted in read-only presentation. */
    label?: React.ReactNode;
};

export type VireoFormReadOnlyValueOwnerState = {
    empty: boolean;
    hasLabel: boolean;
};

Props accepted by {@link VireoFormReadOnlyValue }.

/** Props accepted by {@link VireoFormReadOnlyValue}. */
export type VireoFormReadOnlyValueProps = VireoFormReadOnlyValueOwnProps & VireoFormReadOnlyValueInheritedProps;

export interface VireoFormReadOnlyValueRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoFormReadOnlyValue }.

/** Replaceable semantic regions exposed by {@link VireoFormReadOnlyValue}. */
export type VireoFormReadOnlyValueSlots = {
    [TSlotName in VireoFormReadOnlyValueSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoFormReadOnlyValue }.

/** Slot props exposed by {@link VireoFormReadOnlyValue}. */
export type VireoFormReadOnlyValueSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormReadOnlyValueSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoFormReadOnlyValueRootSlotPropsOverrides, VireoFormReadOnlyValueOwnerState>;
    /** @default Typography */
    label: SlotProps<typeof Typography, VireoFormReadOnlyValueLabelSlotPropsOverrides, VireoFormReadOnlyValueOwnerState>;
    /** @default Typography */
    value: SlotProps<typeof Typography, VireoFormReadOnlyValueValueSlotPropsOverrides, VireoFormReadOnlyValueOwnerState>;
}>;

export interface VireoFormReadOnlyValueValueSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Groups related form content under an accessible heading and a container-responsive layout.

/** Groups related form content under an accessible heading and a container-responsive layout. */
export declare const VireoFormSection: React.ForwardRefExoticComponent<import("./VireoFormSection.types.js").VireoFormSectionSlotsAndSlotProps & {
    children: React.ReactNode;
    classes?: Partial<import("./VireoFormSection.classes.js").VireoFormSectionClasses>;
    description?: React.ReactNode;
    headingLevel?: import("./VireoFormSection.types.js").VireoFormSectionHeadingLevel;
    layout?: import("./VireoFormSection.types.js").VireoFormSectionLayout;
    label: React.ReactNode;
    maxColumns?: import("./VireoFormSection.types.js").VireoFormSectionMaxColumns;
    variant?: import("./VireoFormSection.types.js").VireoFormSectionVariant;
} & import("./VireoFormSection.types.js").VireoFormSectionInheritedProps & React.RefAttributes<HTMLElement>>;

Valid keys for VireoFormSection utility classes and theme style overrides.

/** Valid keys for VireoFormSection utility classes and theme style overrides. */
export type VireoFormSectionClassKey = keyof VireoFormSectionClasses;

Utility classes available to VireoFormSection.

/** Utility classes available to VireoFormSection. */
export type VireoFormSectionClasses = Record<VireoFormSectionSlotName, string>;

export interface VireoFormSectionContentSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSectionDescriptionSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSectionHeaderSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormSectionHeadingLevel = 2 | 3 | 4 | 5 | 6;

export type VireoFormSectionInheritedProps = Omit<BoxProps<"section">, "children" | "component" | "ref">;

Groups one or more elements into a single responsive form-section cell with optional full-row spanning.

/**
 * Groups one or more elements into a single responsive form-section cell with optional full-row spanning.
 */
export declare const VireoFormSectionItem: React.ForwardRefExoticComponent<Omit<VireoFormSectionItemProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

Valid keys for VireoFormSectionItem utility classes and theme style overrides.

/** Valid keys for VireoFormSectionItem utility classes and theme style overrides. */
export type VireoFormSectionItemClassKey = keyof VireoFormSectionItemClasses;

Utility classes available to VireoFormSectionItem.

/** Utility classes available to VireoFormSectionItem. */
export type VireoFormSectionItemClasses = Record<VireoFormSectionItemSlotName, string>;

Props VireoFormSectionItem inherits from its default root after excluding component-owned props.

/** Props VireoFormSectionItem inherits from its default root after excluding component-owned props. */
export type VireoFormSectionItemInheritedProps = Omit<BoxProps<"div">, "children" | "component">;

Props owned by {@link VireoFormSectionItem }.

/** Props owned by {@link VireoFormSectionItem}. */
export type VireoFormSectionItemOwnProps = VireoFormSectionItemSlotsAndSlotProps & {
    children: React.ReactNode;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoFormSectionItemClasses>;
    /** Controls whether the item occupies one cell or the complete responsive row. @default 'auto' */
    span?: VireoFormSectionItemSpan;
};

export type VireoFormSectionItemOwnerState = {
    span: VireoFormSectionItemSpan;
};

Props accepted by {@link VireoFormSectionItem }.

/** Props accepted by {@link VireoFormSectionItem}. */
export type VireoFormSectionItemProps = VireoFormSectionItemOwnProps & VireoFormSectionItemInheritedProps;

export interface VireoFormSectionItemRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoFormSectionItem }.

/** Replaceable semantic regions exposed by {@link VireoFormSectionItem}. */
export type VireoFormSectionItemSlots = {
    [TSlotName in VireoFormSectionItemSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoFormSectionItem }.

/** Slot props exposed by {@link VireoFormSectionItem}. */
export type VireoFormSectionItemSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormSectionItemSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoFormSectionItemRootSlotPropsOverrides, VireoFormSectionItemOwnerState>;
}>;

export type VireoFormSectionItemSpan = "auto" | "full";

export interface VireoFormSectionLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormSectionLayout = "grid" | "stack";

export interface VireoFormSectionLayoutSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormSectionMaxColumns = 1 | 2 | 3;

export type VireoFormSectionOwnProps = VireoFormSectionSlotsAndSlotProps & {
    children: React.ReactNode;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoFormSectionClasses>;
    /** Supporting text associated with the named section. */
    description?: React.ReactNode;
    /** Semantic heading level used for the section label. @default 2 */
    headingLevel?: VireoFormSectionHeadingLevel;
    /** Controls whether fields use a responsive grid or an always-stacked layout. @default 'grid' */
    layout?: VireoFormSectionLayout;
    /** Accessible section heading. */
    label: React.ReactNode;
    /** Maximum number of responsive grid columns. @default 2 */
    maxColumns?: VireoFormSectionMaxColumns;
    /** Controls the section's visual separation from surrounding form content. @default 'divided' */
    variant?: VireoFormSectionVariant;
};

export type VireoFormSectionOwnerState = {
    hasDescription: boolean;
    headingLevel: VireoFormSectionHeadingLevel;
    layout: VireoFormSectionLayout;
    maxColumns: VireoFormSectionMaxColumns;
    variant: VireoFormSectionVariant;
};

export type VireoFormSectionProps = VireoFormSectionOwnProps & VireoFormSectionInheritedProps;

export interface VireoFormSectionRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormSectionSlots = {
    [T in VireoFormSectionSlotName]: React.ElementType;
};

export type VireoFormSectionSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormSectionSlots, {
    /** @default 'section' */
    root: SlotProps<typeof Box, VireoFormSectionRootSlotPropsOverrides, VireoFormSectionOwnerState>;
    /** @default Box */
    header: SlotProps<typeof Box, VireoFormSectionHeaderSlotPropsOverrides, VireoFormSectionOwnerState>;
    /** @default Typography */
    label: SlotProps<typeof Typography, VireoFormSectionLabelSlotPropsOverrides, VireoFormSectionOwnerState>;
    /** @default Typography */
    description: SlotProps<typeof Typography, VireoFormSectionDescriptionSlotPropsOverrides, VireoFormSectionOwnerState>;
    /** @default Box */
    content: SlotProps<typeof Box, VireoFormSectionContentSlotPropsOverrides, VireoFormSectionOwnerState>;
    /** @default Box */
    layout: SlotProps<typeof Box, VireoFormSectionLayoutSlotPropsOverrides, VireoFormSectionOwnerState>;
}>;

export type VireoFormSectionVariant = "divided" | "outlined" | "plain";

Valid keys for VireoFormSelectField utility classes and theme style overrides.

/** Valid keys for VireoFormSelectField utility classes and theme style overrides. */
export type VireoFormSelectFieldClassKey = keyof VireoFormSelectFieldClasses;

Utility classes available to VireoFormSelectField.

/** Utility classes available to VireoFormSelectField. */
export type VireoFormSelectFieldClasses = Record<VireoFormSelectFieldSlotName | VireoFormSelectFieldStateName, string>;

export interface VireoFormSelectFieldClearButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSelectFieldFormHelperTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSelectFieldHtmlInputSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props inherited from MUI TextField after excluding form-owned and Vireo-owned props.

/** Props inherited from MUI TextField after excluding form-owned and Vireo-owned props. */
export type VireoFormSelectFieldInheritedProps = Omit<TextFieldProps, VireoFormSelectFieldComponentOwnedProp>;

export interface VireoFormSelectFieldInputLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSelectFieldInputSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSelectFieldOptionSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSelectFieldOptionTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by the bound form select field. The field name and value remain owned by `form.Field`.

/** Props owned by the bound form select field. The field name and value remain owned by `form.Field`. */
export type VireoFormSelectFieldOwnProps<TOption, TValue extends VireoFormSelectFieldValue> = VireoFormSelectFieldSlotsAndSlotProps & {
    /** Accessible label used by the visible select control. */
    label: React.ReactNode;
    /** Options rendered by the field. */
    options: readonly TOption[];
    /** Returns the stable non-empty scalar value stored by the form for one option. */
    getOptionValue: (option: TOption) => TValue;
    /** Renders one option and the selected-value presentation. */
    renderOption: (option: TOption) => React.ReactNode;
    /** Returns whether one option is unavailable. */
    getOptionDisabled?: (option: TOption) => boolean;
    /** Override or extend the utility classes applied to each slot and state. */
    classes?: Partial<VireoFormSelectFieldClasses>;
    disabled?: boolean;
    /** Adds an error presentation state without suppressing validation errors. */
    error?: boolean;
    /** Overrides the enclosing form's error-display policy for this field. */
    errorDisplay?: VireoFormErrorDisplay;
    /** Overrides the enclosing form's validation-error formatter for this field. */
    formatError?: VireoFormErrorFormatter;
    /** @default true */
    fullWidth?: boolean;
    /** Shown when no visible validation error takes precedence. Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    /** Text rendered when the bound value is `null`. */
    placeholder?: React.ReactNode;
    /** Prevents the selected value from being cleared. @default false */
    disableClearable?: boolean;
    /** Accessible label for the clear action. @default 'Clear selection' */
    clearLabel?: string;
    /** Replaces the default clear icon without replacing the button slot. */
    clearIcon?: React.ReactNode;
    /** Ref forwarded to MUI's select input. */
    inputRef?: SelectProps<TValue>["inputRef"];
    onBlur?: NonNullable<SelectProps<TValue>["onBlur"]>;
    /** Observes accepted option and clear changes after cancelable slot handlers. */
    onValueChange?: (value: TValue | null) => void;
    readOnly?: boolean;
    readOnlyEmptyValue?: React.ReactNode;
    renderReadOnlyValue?: (value: TValue, option: TOption | undefined) => React.ReactNode;
    required?: boolean;
};

export type VireoFormSelectFieldOwnerState = {
    dirty: boolean;
    disabled: boolean;
    errorVisible: boolean;
    hasValue: boolean;
    invalid: boolean;
    readOnly: boolean;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
};

Props accepted by `field.SelectField`.

/** Props accepted by `field.SelectField`. */
export type VireoFormSelectFieldProps<TOption = unknown, TValue extends VireoFormSelectFieldValue = VireoFormSelectFieldValue> = VireoFormSelectFieldOwnProps<TOption, TValue> & VireoFormSelectFieldInheritedProps;

export interface VireoFormSelectFieldRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSelectFieldSelectSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by the bound form select field.

/** Replaceable semantic regions exposed by the bound form select field. */
export type VireoFormSelectFieldSlots = {
    root: React.ElementType;
    inputLabel: React.ElementType;
    input: React.ElementType;
    htmlInput: React.ElementType;
    select: React.ElementType;
    option: React.ElementType;
    optionText: React.ElementType;
    clearButton: React.ElementType;
    formHelperText: React.ElementType;
};

Slot props exposed by the bound form select field.

/** Slot props exposed by the bound form select field. */
export type VireoFormSelectFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormSelectFieldSlots, {
    /** @default FormControl */
    root: SlotProps<typeof FormControl, VireoFormSelectFieldRootSlotPropsOverrides, VireoFormSelectFieldOwnerState>;
    /** @default InputLabel */
    inputLabel: SlotProps<typeof InputLabel, VireoFormSelectFieldInputLabelSlotPropsOverrides, VireoFormSelectFieldOwnerState>;
    /** @default OutlinedInput; follows `variant` for standard and filled fields. */
    input: SlotProps<typeof OutlinedInput, VireoFormSelectFieldInputSlotPropsOverrides, VireoFormSelectFieldOwnerState>;
    /** @default 'input' */
    htmlInput: SlotProps<"input", VireoFormSelectFieldHtmlInputSlotPropsOverrides, VireoFormSelectFieldOwnerState>;
    /** @default Select */
    select: SlotProps<typeof Select, VireoFormSelectFieldSelectSlotPropsOverrides, VireoFormSelectFieldOwnerState>;
    /** @default MenuItem */
    option: SlotProps<typeof MenuItem, VireoFormSelectFieldOptionSlotPropsOverrides, VireoFormSelectFieldOwnerState>;
    /** @default ListItemText */
    optionText: SlotProps<typeof ListItemText, VireoFormSelectFieldOptionTextSlotPropsOverrides, VireoFormSelectFieldOwnerState>;
    /** @default IconButton */
    clearButton: SlotProps<typeof IconButton, VireoFormSelectFieldClearButtonSlotPropsOverrides, VireoFormSelectFieldOwnerState>;
    /** @default FormHelperText */
    formHelperText: SlotProps<typeof FormHelperText, VireoFormSelectFieldFormHelperTextSlotPropsOverrides, VireoFormSelectFieldOwnerState>;
}>;

Scalar values supported by `field.SelectField`. Objects remain represented by their stable option value.

/** Scalar values supported by `field.SelectField`. Objects remain represented by their stable option value. */
export type VireoFormSelectFieldValue = string | number;

Valid keys for VireoFormSelectMultipleField utility classes and theme style overrides.

/** Valid keys for VireoFormSelectMultipleField utility classes and theme style overrides. */
export type VireoFormSelectMultipleFieldClassKey = keyof VireoFormSelectMultipleFieldClasses;

Utility classes available to VireoFormSelectMultipleField.

/** Utility classes available to VireoFormSelectMultipleField. */
export type VireoFormSelectMultipleFieldClasses = Record<VireoFormSelectMultipleFieldSlotName | VireoFormSelectMultipleFieldStateName, string>;

export interface VireoFormSelectMultipleFieldClearButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSelectMultipleFieldFormHelperTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSelectMultipleFieldHtmlInputSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props inherited from MUI TextField after excluding form-owned and Vireo-owned props.

/** Props inherited from MUI TextField after excluding form-owned and Vireo-owned props. */
export type VireoFormSelectMultipleFieldInheritedProps = Omit<TextFieldProps, VireoFormSelectMultipleFieldComponentOwnedProp>;

export interface VireoFormSelectMultipleFieldInputLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSelectMultipleFieldInputSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSelectMultipleFieldOptionCheckboxSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSelectMultipleFieldOptionSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSelectMultipleFieldOptionTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by the bound form multiple-select field. The field name and array value remain owned by `form.Field`.

/** Props owned by the bound form multiple-select field. The field name and array value remain owned by `form.Field`. */
export type VireoFormSelectMultipleFieldOwnProps<TOption, TValue extends VireoFormSelectMultipleFieldValue> = VireoFormSelectMultipleFieldSlotsAndSlotProps & {
    /** Accessible label used by the visible select control. */
    label: React.ReactNode;
    /** Options rendered by the field. */
    options: readonly TOption[];
    /** Returns the stable non-empty scalar value stored for one option. */
    getOptionValue: (option: TOption) => TValue;
    /** Renders one dropdown option and the default selected-value summary item. */
    renderOption: (option: TOption) => React.ReactNode;
    /** Replaces the complete selected-value presentation. */
    renderSelectedOptions?: (params: VireoFormSelectMultipleFieldRenderSelectedOptionsParams<TOption>) => React.ReactNode;
    /** Maximum option labels shown by the compact default summary. @default 2 */
    maxDisplayedOptions?: number;
    /** Returns whether one option is unavailable. */
    getOptionDisabled?: (option: TOption) => boolean;
    /** Override or extend the utility classes applied to each slot and state. */
    classes?: Partial<VireoFormSelectMultipleFieldClasses>;
    disabled?: boolean;
    /** Adds an error presentation state without suppressing validation errors. */
    error?: boolean;
    /** Overrides the enclosing form's error-display policy for this field. */
    errorDisplay?: VireoFormErrorDisplay;
    /** Overrides the enclosing form's validation-error formatter for this field. */
    formatError?: VireoFormErrorFormatter;
    /** @default true */
    fullWidth?: boolean;
    /** Shown when no visible validation error takes precedence. Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    /** Text rendered when the bound value is empty. */
    placeholder?: React.ReactNode;
    /** Prevents all selected values from being cleared at once. @default false */
    disableClearable?: boolean;
    /** Accessible label for the clear-all action. @default 'Clear selections' */
    clearLabel?: string;
    /** Replaces the default clear icon without replacing the button slot. */
    clearIcon?: React.ReactNode;
    /** Ref forwarded to MUI's select input. */
    inputRef?: SelectProps<TValue[]>["inputRef"];
    onBlur?: NonNullable<SelectProps<TValue[]>["onBlur"]>;
    /** Observes accepted selection and clear-all changes after cancelable slot handlers. */
    onValueChange?: (value: TValue[]) => void;
    readOnly?: boolean;
    readOnlyEmptyValue?: React.ReactNode;
    renderReadOnlyValue?: (values: readonly TValue[], selectedOptions: readonly TOption[]) => React.ReactNode;
    required?: boolean;
};

export type VireoFormSelectMultipleFieldOwnerState = {
    dirty: boolean;
    disabled: boolean;
    errorVisible: boolean;
    hasValue: boolean;
    invalid: boolean;
    readOnly: boolean;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
};

Props accepted by `field.SelectMultipleField`.

/** Props accepted by `field.SelectMultipleField`. */
export type VireoFormSelectMultipleFieldProps<TOption = unknown, TValue extends VireoFormSelectMultipleFieldValue = VireoFormSelectMultipleFieldValue> = VireoFormSelectMultipleFieldOwnProps<TOption, TValue> & VireoFormSelectMultipleFieldInheritedProps;

export type VireoFormSelectMultipleFieldRenderSelectedOptionsParams<TOption> = {
    /** Every recognized selected option, in the bound value array's order. */
    selectedOptions: readonly TOption[];
    /** The leading options included by `maxDisplayedOptions`. */
    displayedOptions: readonly TOption[];
    /** Number of recognized selected options omitted from `displayedOptions`. */
    hiddenCount: number;
    /** Resolved non-negative compact-summary limit. */
    maxDisplayedOptions: number;
};

export interface VireoFormSelectMultipleFieldRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSelectMultipleFieldSelectSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSelectMultipleFieldSelectionSummarySlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by the bound form multiple-select field.

/** Replaceable semantic regions exposed by the bound form multiple-select field. */
export type VireoFormSelectMultipleFieldSlots = {
    root: React.ElementType;
    inputLabel: React.ElementType;
    input: React.ElementType;
    htmlInput: React.ElementType;
    select: React.ElementType;
    selectionSummary: React.ElementType;
    option: React.ElementType;
    optionCheckbox: React.ElementType;
    optionText: React.ElementType;
    clearButton: React.ElementType;
    formHelperText: React.ElementType;
};

Slot props exposed by the bound form multiple-select field.

/** Slot props exposed by the bound form multiple-select field. */
export type VireoFormSelectMultipleFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormSelectMultipleFieldSlots, {
    /** @default FormControl */
    root: SlotProps<typeof FormControl, VireoFormSelectMultipleFieldRootSlotPropsOverrides, VireoFormSelectMultipleFieldOwnerState>;
    /** @default InputLabel */
    inputLabel: SlotProps<typeof InputLabel, VireoFormSelectMultipleFieldInputLabelSlotPropsOverrides, VireoFormSelectMultipleFieldOwnerState>;
    /** @default OutlinedInput; follows `variant` for standard and filled fields. */
    input: SlotProps<typeof OutlinedInput, VireoFormSelectMultipleFieldInputSlotPropsOverrides, VireoFormSelectMultipleFieldOwnerState>;
    /** @default 'input' */
    htmlInput: SlotProps<"input", VireoFormSelectMultipleFieldHtmlInputSlotPropsOverrides, VireoFormSelectMultipleFieldOwnerState>;
    /** @default Select */
    select: SlotProps<typeof Select, VireoFormSelectMultipleFieldSelectSlotPropsOverrides, VireoFormSelectMultipleFieldOwnerState>;
    /** @default Typography */
    selectionSummary: SlotProps<typeof Typography, VireoFormSelectMultipleFieldSelectionSummarySlotPropsOverrides, VireoFormSelectMultipleFieldOwnerState>;
    /** @default MenuItem */
    option: SlotProps<typeof MenuItem, VireoFormSelectMultipleFieldOptionSlotPropsOverrides, VireoFormSelectMultipleFieldOwnerState>;
    /** @default Checkbox */
    optionCheckbox: SlotProps<typeof Checkbox, VireoFormSelectMultipleFieldOptionCheckboxSlotPropsOverrides, VireoFormSelectMultipleFieldOwnerState>;
    /** @default ListItemText */
    optionText: SlotProps<typeof ListItemText, VireoFormSelectMultipleFieldOptionTextSlotPropsOverrides, VireoFormSelectMultipleFieldOwnerState>;
    /** @default IconButton */
    clearButton: SlotProps<typeof IconButton, VireoFormSelectMultipleFieldClearButtonSlotPropsOverrides, VireoFormSelectMultipleFieldOwnerState>;
    /** @default FormHelperText */
    formHelperText: SlotProps<typeof FormHelperText, VireoFormSelectMultipleFieldFormHelperTextSlotPropsOverrides, VireoFormSelectMultipleFieldOwnerState>;
}>;

Scalar option identifiers stored in arrays by `field.SelectMultipleField`.

/** Scalar option identifiers stored in arrays by `field.SelectMultipleField`. */
export type VireoFormSelectMultipleFieldValue = string | number;

Replaceable semantic regions exposed by {@link VireoForm }.

/** Replaceable semantic regions exposed by {@link VireoForm}. */
export type VireoFormSlots = {
    [TSlotName in VireoFormSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoForm }.

/** Slot props exposed by {@link VireoForm}. */
export type VireoFormSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormSlots, {
    /** @default 'form' */
    root: SlotProps<"form", VireoFormRootSlotPropsOverrides, VireoFormOwnerState>;
}>;

Valid keys for VireoFormStep utility classes and theme style overrides.

/** Valid keys for VireoFormStep utility classes and theme style overrides. */
export type VireoFormStepClassKey = keyof VireoFormStepClasses;

Utility classes available to VireoFormStep.

/** Utility classes available to VireoFormStep. */
export type VireoFormStepClasses = Record<VireoFormStepSlotName, string>;

Props VireoFormStep inherits from its default root after excluding component-owned props.

/** Props VireoFormStep inherits from its default root after excluding component-owned props. */
export type VireoFormStepInheritedProps = Omit<BoxProps<"section">, "children" | "component" | "id">;

export interface VireoFormStepLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by {@link VireoFormStep }.

/** Props owned by {@link VireoFormStep}. */
export type VireoFormStepOwnProps = VireoFormStepSlotsAndSlotProps & {
    children?: React.ReactNode;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoFormStepClasses>;
    /** Stable configured step id. */
    id: string;
};

export type VireoFormStepOwnerState = {
    active: boolean;
    current: boolean;
    direction: VireoMultiStepDirection;
    keepMounted: boolean;
};

Valid keys for VireoFormStepProgress utility classes and theme style overrides.

/** Valid keys for VireoFormStepProgress utility classes and theme style overrides. */
export type VireoFormStepProgressClassKey = keyof VireoFormStepProgressClasses;

Utility classes available to VireoFormStepProgress.

/** Utility classes available to VireoFormStepProgress. */
export type VireoFormStepProgressClasses = Record<VireoFormStepProgressSlotName, string>;

export interface VireoFormStepProgressCompactCountSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormStepProgressCompactLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormStepProgressCompactProgressSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormStepProgressCompactRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormStepProgressCompactTriggerSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormStepProgressConnectorSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormStepProgressInheritedProps = Omit<BoxProps<"nav">, "component" | "ref">;

export type VireoFormStepProgressLayout = "responsive" | "horizontal" | "compact";

export interface VireoFormStepProgressListSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormStepProgressMenuItemSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormStepProgressMenuSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormStepProgressNavigation = "none" | "visited" | "all";

export type VireoFormStepProgressOwnProps = VireoFormStepProgressSlotsAndSlotProps & {
    /** Container width at which responsive progress changes to its compact presentation. @default 600 */
    compactBreakpoint?: number;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoFormStepProgressClasses>;
    /** Chooses the wide, compact, or container-responsive presentation. @default 'responsive' */
    layout?: VireoFormStepProgressLayout;
    /** Controls which steps can be selected directly from progress navigation. @default 'visited' */
    navigation?: VireoFormStepProgressNavigation;
};

export type VireoFormStepProgressOwnerState = {
    compactBreakpoint: number;
    layout: VireoFormStepProgressLayout;
    navigation: VireoFormStepProgressNavigation;
    step?: VireoMultiStepStepState<string>;
};

export type VireoFormStepProgressProps = VireoFormStepProgressOwnProps & VireoFormStepProgressInheritedProps;

export interface VireoFormStepProgressRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormStepProgressSlots = {
    [T in VireoFormStepProgressSlotName]: React.ElementType;
};

export type VireoFormStepProgressSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormStepProgressSlots, {
    /** @default 'nav' */
    root: SlotProps<typeof Box, VireoFormStepProgressRootSlotPropsOverrides, VireoFormStepProgressOwnerState>;
    /** @default 'ol' */
    list: SlotProps<typeof Box, VireoFormStepProgressListSlotPropsOverrides, VireoFormStepProgressOwnerState>;
    /** @default 'li' */
    step: SlotProps<typeof Box, VireoFormStepProgressStepSlotPropsOverrides, VireoFormStepProgressOwnerState>;
    /** @default ButtonBase */
    stepButton: SlotProps<typeof ButtonBase, VireoFormStepProgressStepButtonSlotPropsOverrides, VireoFormStepProgressOwnerState>;
    /** @default 'span' */
    statusIcon: SlotProps<typeof Box, VireoFormStepProgressStatusIconSlotPropsOverrides, VireoFormStepProgressOwnerState>;
    /** @default 'span' */
    stepLabel: SlotProps<typeof Typography, VireoFormStepProgressStepLabelSlotPropsOverrides, VireoFormStepProgressOwnerState>;
    /** @default 'span' */
    connector: SlotProps<typeof Box, VireoFormStepProgressConnectorSlotPropsOverrides, VireoFormStepProgressOwnerState>;
    /** @default Box */
    compactRoot: SlotProps<typeof Box, VireoFormStepProgressCompactRootSlotPropsOverrides, VireoFormStepProgressOwnerState>;
    /** @default ButtonBase */
    compactTrigger: SlotProps<typeof ButtonBase, VireoFormStepProgressCompactTriggerSlotPropsOverrides, VireoFormStepProgressOwnerState>;
    /** @default 'span' */
    compactLabel: SlotProps<typeof Typography, VireoFormStepProgressCompactLabelSlotPropsOverrides, VireoFormStepProgressOwnerState>;
    /** @default 'span' */
    compactCount: SlotProps<typeof Typography, VireoFormStepProgressCompactCountSlotPropsOverrides, VireoFormStepProgressOwnerState>;
    /** @default LinearProgress */
    compactProgress: SlotProps<typeof LinearProgress, VireoFormStepProgressCompactProgressSlotPropsOverrides, VireoFormStepProgressOwnerState>;
    /** @default Menu */
    menu: SlotProps<typeof Menu, VireoFormStepProgressMenuSlotPropsOverrides, VireoFormStepProgressOwnerState>;
    /** @default MenuItem */
    menuItem: SlotProps<typeof MenuItem, VireoFormStepProgressMenuItemSlotPropsOverrides, VireoFormStepProgressOwnerState>;
}>;

export interface VireoFormStepProgressStatusIconSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormStepProgressStepButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormStepProgressStepLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormStepProgressStepSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props accepted by {@link VireoFormStep }.

/** Props accepted by {@link VireoFormStep}. */
export type VireoFormStepProps = VireoFormStepOwnProps & VireoFormStepInheritedProps;

export interface VireoFormStepRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoFormStep }.

/** Replaceable semantic regions exposed by {@link VireoFormStep}. */
export type VireoFormStepSlots = {
    [TSlotName in VireoFormStepSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoFormStep }.

/** Slot props exposed by {@link VireoFormStep}. */
export type VireoFormStepSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormStepSlots, {
    /** @default 'section' */
    root: SlotProps<"section", VireoFormStepRootSlotPropsOverrides, VireoFormStepOwnerState>;
    /** @default Typography */
    label: SlotProps<typeof Typography, VireoFormStepLabelSlotPropsOverrides, VireoFormStepOwnerState>;
}>;

Valid keys for VireoFormSubmitButton utility classes and theme style overrides.

/** Valid keys for VireoFormSubmitButton utility classes and theme style overrides. */
export type VireoFormSubmitButtonClassKey = keyof VireoFormSubmitButtonClasses;

Utility classes available to VireoFormSubmitButton.

/** Utility classes available to VireoFormSubmitButton. */
export type VireoFormSubmitButtonClasses = Record<VireoFormSubmitButtonSlotName | VireoFormSubmitButtonStateName, string>;

Props VireoFormSubmitButton inherits from its default root after excluding component-owned props.

/** Props VireoFormSubmitButton inherits from its default root after excluding component-owned props. */
export type VireoFormSubmitButtonInheritedProps = Omit<ButtonProps, "component" | "href" | "loading" | "type">;

Props owned by {@link VireoFormSubmitButton }.

/** Props owned by {@link VireoFormSubmitButton}. */
export type VireoFormSubmitButtonOwnProps = VireoFormSubmitButtonSlotsAndSlotProps & {
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoFormSubmitButtonClasses>;
    /** Adds a consumer-owned loading condition to the form's submission state. @default false */
    loading?: boolean | null;
    /** Controls whether a multi-step submit action is rendered only on the final step. @default 'auto' */
    visibility?: "auto" | "always";
};

export type VireoFormSubmitButtonOwnerState = {
    available: boolean;
    disabled: boolean;
    loading: boolean;
    submitting: boolean;
};

Props accepted by {@link VireoFormSubmitButton }.

/** Props accepted by {@link VireoFormSubmitButton}. */
export type VireoFormSubmitButtonProps = VireoFormSubmitButtonOwnProps & VireoFormSubmitButtonInheritedProps;

export interface VireoFormSubmitButtonRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoFormSubmitButton }.

/** Replaceable semantic regions exposed by {@link VireoFormSubmitButton}. */
export type VireoFormSubmitButtonSlots = {
    [TSlotName in VireoFormSubmitButtonSlotName]: React.ElementType;
};

Slot props exposed by {@link VireoFormSubmitButton }.

/** Slot props exposed by {@link VireoFormSubmitButton}. */
export type VireoFormSubmitButtonSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormSubmitButtonSlots, {
    /** @default Button */
    root: SlotProps<typeof Button, VireoFormSubmitButtonRootSlotPropsOverrides, VireoFormSubmitButtonOwnerState>;
}>;

Valid keys for VireoFormSwitchField utility classes and theme style overrides.

/** Valid keys for VireoFormSwitchField utility classes and theme style overrides. */
export type VireoFormSwitchFieldClassKey = keyof VireoFormSwitchFieldClasses;

Utility classes available to VireoFormSwitchField.

/** Utility classes available to VireoFormSwitchField. */
export type VireoFormSwitchFieldClasses = Record<VireoFormSwitchFieldSlotName | VireoFormSwitchFieldStateName, string>;

export interface VireoFormSwitchFieldFormControlLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormSwitchFieldFormHelperTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoFormSwitchField inherits from its default root after excluding component-owned props.

/** Props VireoFormSwitchField inherits from its default root after excluding component-owned props. */
export type VireoFormSwitchFieldInheritedProps = Omit<FormControlProps, VireoFormSwitchFieldComponentOwnedProp>;

export interface VireoFormSwitchFieldLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by the bound form switch field. The field name and checked value remain owned by `form.Field`.

/** Props owned by the bound form switch field. The field name and checked value remain owned by `form.Field`. */
export type VireoFormSwitchFieldOwnProps = VireoFormSwitchFieldSlotsAndSlotProps & {
    /** Override or extend the utility classes applied to each slot and state. */
    classes?: Partial<VireoFormSwitchFieldClasses>;
    disabled?: boolean;
    /** Adds an error presentation state without suppressing validation errors. */
    error?: boolean;
    /** Overrides the enclosing form's error-display policy for this field. */
    errorDisplay?: VireoFormErrorDisplay;
    /** Overrides the enclosing form's validation-error formatter for this field. */
    formatError?: VireoFormErrorFormatter;
    /** @default true */
    fullWidth?: boolean;
    /** Shown when no visible validation error takes precedence. Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    /** Ref forwarded to the native checkbox input. */
    inputRef?: React.Ref<HTMLInputElement>;
    /** Visible accessible label rendered beside the switch. */
    label: React.ReactNode;
    /** @default 'end' */
    labelPlacement?: FormControlLabelProps["labelPlacement"];
    onBlur?: NonNullable<SwitchProps["onBlur"]>;
    onChange?: NonNullable<SwitchProps["onChange"]>;
    readOnly?: boolean;
    readOnlyEmptyValue?: React.ReactNode;
    renderReadOnlyValue?: (value: boolean) => React.ReactNode;
    required?: boolean;
};

export type VireoFormSwitchFieldOwnerState = {
    checked: boolean;
    dirty: boolean;
    disabled: boolean;
    errorVisible: boolean;
    invalid: boolean;
    readOnly: boolean;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
};

Props accepted by `field.SwitchField`.

/** Props accepted by `field.SwitchField`. */
export type VireoFormSwitchFieldProps = VireoFormSwitchFieldOwnProps & VireoFormSwitchFieldInheritedProps;

export interface VireoFormSwitchFieldRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by the bound form switch field.

/** Replaceable semantic regions exposed by the bound form switch field. */
export type VireoFormSwitchFieldSlots = {
    root: React.ElementType;
    formControlLabel: React.ElementType;
    switch: React.ElementType;
    label: React.ElementType;
    formHelperText: React.ElementType;
};

Slot props exposed by the bound form switch field.

/** Slot props exposed by the bound form switch field. */
export type VireoFormSwitchFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormSwitchFieldSlots, {
    /** @default FormControl */
    root: SlotProps<typeof FormControl, VireoFormSwitchFieldRootSlotPropsOverrides, VireoFormSwitchFieldOwnerState>;
    /** @default FormControlLabel */
    formControlLabel: SlotProps<typeof FormControlLabel, VireoFormSwitchFieldFormControlLabelSlotPropsOverrides, VireoFormSwitchFieldOwnerState>;
    /** @default Switch */
    switch: SlotProps<typeof Switch, VireoFormSwitchFieldSwitchSlotPropsOverrides, VireoFormSwitchFieldOwnerState>;
    /** @default Typography */
    label: SlotProps<typeof Typography, VireoFormSwitchFieldLabelSlotPropsOverrides, VireoFormSwitchFieldOwnerState>;
    /** @default FormHelperText */
    formHelperText: SlotProps<typeof FormHelperText, VireoFormSwitchFieldFormHelperTextSlotPropsOverrides, VireoFormSwitchFieldOwnerState>;
}>;

export interface VireoFormSwitchFieldSwitchSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
    /** Compatibility alias merged into MUI's native `input` slot. */
    inputProps?: React.InputHTMLAttributes<HTMLInputElement>;
    /** Compatibility alias forwarded to MUI's native `input` slot. */
    inputRef?: React.Ref<HTMLInputElement>;
}

Valid keys for VireoFormTemporalField utility classes and theme style overrides.

/** Valid keys for VireoFormTemporalField utility classes and theme style overrides. */
export type VireoFormTemporalFieldClassKey = keyof VireoFormTemporalFieldClasses;

Utility classes available to VireoFormTemporalField.

/** Utility classes available to VireoFormTemporalField. */
export type VireoFormTemporalFieldClasses = Record<VireoFormTemporalFieldSlotName | "dirty" | "touched" | "invalid" | "errorVisible" | "validating" | "submitting" | "disabled" | "readOnly" | "hasValue", string>;

export interface VireoFormTemporalFieldClearButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormTemporalFieldClearIconSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormTemporalFieldDatePickerProps = Omit<DatePickerProps, VireoOwnedPickerProp>;

export type VireoFormTemporalFieldDateTimePickerProps = Omit<DateTimePickerProps, VireoOwnedPickerProp>;

export type VireoFormTemporalFieldError = "invalid" | "min" | "max" | "minuteStep" | "secondStep";

export interface VireoFormTemporalFieldFormHelperTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormTemporalFieldHtmlInputSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoFormTemporalField inherits from its default root after excluding component-owned props.

/** Props VireoFormTemporalField inherits from its default root after excluding component-owned props. */
export type VireoFormTemporalFieldInheritedProps = Omit<BoxProps<"div">, "children" | "component" | "defaultValue" | "onChange" | "onError" | "value">;

export interface VireoFormTemporalFieldInputSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormTemporalFieldMode = "year" | "month" | "year-month" | "date" | "time" | "date-time";

export type VireoFormTemporalFieldModeProps = {
    mode: "year";
    openTo?: "year";
    pickerProps?: VireoFormTemporalFieldDatePickerProps;
    ampm?: never;
    precision?: never;
    minuteStep?: never;
    secondStep?: never;
} | {
    mode: "month";
    openTo?: "month";
    pickerProps?: VireoFormTemporalFieldDatePickerProps;
    ampm?: never;
    precision?: never;
    minuteStep?: never;
    secondStep?: never;
} | {
    mode: "year-month";
    openTo?: "year" | "month";
    pickerProps?: VireoFormTemporalFieldDatePickerProps;
    ampm?: never;
    precision?: never;
    minuteStep?: never;
    secondStep?: never;
} | {
    mode: "date";
    openTo?: "year" | "month" | "day";
    pickerProps?: VireoFormTemporalFieldDatePickerProps;
    ampm?: never;
    precision?: never;
    minuteStep?: never;
    secondStep?: never;
} | {
    mode: "time";
    openTo?: "hours" | "minutes" | "seconds";
    pickerProps?: VireoFormTemporalFieldTimePickerProps;
    /** @default false */
    ampm?: boolean;
    /** @default 'minute' */
    precision?: VireoFormTemporalFieldPrecision;
    /** @default 1 */
    minuteStep?: number;
    /** @default 1 */
    secondStep?: number;
} | {
    mode: "date-time";
    openTo?: "year" | "month" | "day" | "hours" | "minutes" | "seconds";
    pickerProps?: VireoFormTemporalFieldDateTimePickerProps;
    /** @default false */
    ampm?: boolean;
    /** @default 'minute' */
    precision?: VireoFormTemporalFieldPrecision;
    /** @default 1 */
    minuteStep?: number;
    /** @default 1 */
    secondStep?: number;
};

export interface VireoFormTemporalFieldOpenPickerButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormTemporalFieldOpenPickerIconSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by the bound temporal form field. The field name and value remain owned by `form.Field`.

/** Props owned by the bound temporal form field. The field name and value remain owned by `form.Field`. */
export type VireoFormTemporalFieldOwnProps = VireoFormTemporalFieldCommonProps & VireoFormTemporalFieldModeProps;

export type VireoFormTemporalFieldOwnerState = {
    dirty: boolean;
    disabled: boolean;
    errorVisible: boolean;
    hasValue: boolean;
    invalid: boolean;
    mode: VireoFormTemporalFieldMode;
    readOnly: boolean;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
};

export type VireoFormTemporalFieldPickerError = DateValidationError | TimeValidationError | DateTimeValidationError;

export type VireoFormTemporalFieldPrecision = "minute" | "second";

Props accepted by `field.TemporalField`.

/** Props accepted by `field.TemporalField`. */
export type VireoFormTemporalFieldProps = VireoFormTemporalFieldOwnProps & VireoFormTemporalFieldInheritedProps;

export interface VireoFormTemporalFieldRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormTemporalFieldSlots = {
    [TSlotName in VireoFormTemporalFieldSlotName]: React.ElementType;
};

export type VireoFormTemporalFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormTemporalFieldSlots, {
    /** @default 'div' */
    root: SlotProps<"div", VireoFormTemporalFieldRootSlotPropsOverrides, VireoFormTemporalFieldOwnerState>;
    /** @default PickersOutlinedInput; follows `variant` for standard and filled fields. */
    input: SlotProps<typeof PickersOutlinedInput, VireoFormTemporalFieldInputSlotPropsOverrides, VireoFormTemporalFieldOwnerState>;
    /** @default 'input' */
    htmlInput: SlotProps<"input", VireoFormTemporalFieldHtmlInputSlotPropsOverrides, VireoFormTemporalFieldOwnerState>;
    /** @default FormHelperText */
    formHelperText: SlotProps<typeof FormHelperText, VireoFormTemporalFieldFormHelperTextSlotPropsOverrides, VireoFormTemporalFieldOwnerState>;
    /** @default IconButton */
    openPickerButton: SlotProps<typeof IconButton, VireoFormTemporalFieldOpenPickerButtonSlotPropsOverrides, VireoFormTemporalFieldOwnerState>;
    /** @default CalendarIcon */
    openPickerIcon: SlotProps<typeof SvgIcon, VireoFormTemporalFieldOpenPickerIconSlotPropsOverrides, VireoFormTemporalFieldOwnerState>;
    /** @default IconButton */
    clearButton: SlotProps<typeof IconButton, VireoFormTemporalFieldClearButtonSlotPropsOverrides, VireoFormTemporalFieldOwnerState>;
    /** @default ClearIcon */
    clearIcon: SlotProps<typeof SvgIcon, VireoFormTemporalFieldClearIconSlotPropsOverrides, VireoFormTemporalFieldOwnerState>;
}>;

export type VireoFormTemporalFieldTimePickerProps = Omit<TimePickerProps, VireoOwnedPickerProp>;

export type VireoFormTemporalFieldValue = string | null;

Valid keys for VireoFormTextField utility classes and theme style overrides.

/** Valid keys for VireoFormTextField utility classes and theme style overrides. */
export type VireoFormTextFieldClassKey = keyof VireoFormTextFieldClasses;

Utility classes available to VireoFormTextField.

/** Utility classes available to VireoFormTextField. */
export type VireoFormTextFieldClasses = Record<VireoFormTextFieldSlotName | VireoFormTextFieldStateName, string>;

export interface VireoFormTextFieldFormHelperTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormTextFieldHtmlInputSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props inherited from MUI TextField after excluding form-owned and Vireo-owned props.

/** Props inherited from MUI TextField after excluding form-owned and Vireo-owned props. */
export type VireoFormTextFieldInheritedProps = Omit<TextFieldProps, VireoFormTextFieldComponentOwnedProp>;

export interface VireoFormTextFieldInputLabelSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormTextFieldInputSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props owned by the bound form text field. The field name and value remain owned by `form.Field`.

/** Props owned by the bound form text field. The field name and value remain owned by `form.Field`. */
export type VireoFormTextFieldOwnProps = VireoFormTextFieldSlotsAndSlotProps & {
    /** Override or extend the utility classes applied to each slot and state. */
    classes?: Partial<VireoFormTextFieldClasses>;
    disabled?: boolean;
    /** Adds an error presentation state without suppressing validation errors. */
    error?: boolean;
    /** Overrides the enclosing form's error-display policy for this field. */
    errorDisplay?: VireoFormErrorDisplay;
    /** Overrides the enclosing form's validation-error formatter for this field. */
    formatError?: VireoFormErrorFormatter;
    /** @default true */
    fullWidth?: boolean;
    /** Shown when no visible validation error takes precedence. Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    /** Ref forwarded to the native input or textarea. */
    inputRef?: React.Ref<HTMLElement>;
    onBlur?: NonNullable<TextFieldProps["onBlur"]>;
    onChange?: NonNullable<TextFieldProps["onChange"]>;
    readOnly?: boolean;
    /** Overrides the enclosing form's fallback for an empty read-only value. */
    readOnlyEmptyValue?: React.ReactNode;
    /** Replaces the default string presentation in read-only mode. */
    renderReadOnlyValue?: (value: string) => React.ReactNode;
    required?: boolean;
};

export type VireoFormTextFieldOwnerState = {
    dirty: boolean;
    disabled: boolean;
    errorVisible: boolean;
    invalid: boolean;
    readOnly: boolean;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
};

Props accepted by `field.TextField`.

/** Props accepted by `field.TextField`. */
export type VireoFormTextFieldProps = VireoFormTextFieldOwnProps & VireoFormTextFieldInheritedProps;

export interface VireoFormTextFieldRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormTextFieldSelectSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by the bound form text field.

/** Replaceable semantic regions exposed by the bound form text field. */
export type VireoFormTextFieldSlots = {
    root: React.ElementType;
    inputLabel: React.ElementType;
    input: React.ElementType;
    htmlInput: React.ElementType;
    formHelperText: React.ElementType;
    select: React.ElementType;
};

Slot props exposed by the bound form text field.

/** Slot props exposed by the bound form text field. */
export type VireoFormTextFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormTextFieldSlots, {
    /** @default FormControl */
    root: SlotProps<typeof FormControl, VireoFormTextFieldRootSlotPropsOverrides, VireoFormTextFieldOwnerState>;
    /** @default InputLabel */
    inputLabel: SlotProps<typeof InputLabel, VireoFormTextFieldInputLabelSlotPropsOverrides, VireoFormTextFieldOwnerState>;
    /** @default OutlinedInput; follows `variant` for standard and filled fields. */
    input: SlotProps<typeof OutlinedInput, VireoFormTextFieldInputSlotPropsOverrides, VireoFormTextFieldOwnerState>;
    /** @default 'input' */
    htmlInput: SlotProps<"input", VireoFormTextFieldHtmlInputSlotPropsOverrides, VireoFormTextFieldOwnerState>;
    /** @default FormHelperText */
    formHelperText: SlotProps<typeof FormHelperText, VireoFormTextFieldFormHelperTextSlotPropsOverrides, VireoFormTextFieldOwnerState>;
    /** @default Select */
    select: SlotProps<typeof Select, VireoFormTextFieldSelectSlotPropsOverrides, VireoFormTextFieldOwnerState>;
}>;

Accessible naming contract for the toggle-button group itself.

/** Accessible naming contract for the toggle-button group itself. */
export type VireoFormToggleButtonGroupFieldAccessibleNameProps = {
    "aria-label": string;
    "aria-labelledby"?: string;
} | {
    "aria-label"?: undefined;
    "aria-labelledby": string;
};

Valid keys for VireoFormToggleButtonGroupField utility classes and theme style overrides.

/** Valid keys for VireoFormToggleButtonGroupField utility classes and theme style overrides. */
export type VireoFormToggleButtonGroupFieldClassKey = keyof VireoFormToggleButtonGroupFieldClasses;

Utility classes available to VireoFormToggleButtonGroupField.

/** Utility classes available to VireoFormToggleButtonGroupField. */
export type VireoFormToggleButtonGroupFieldClasses = Record<VireoFormToggleButtonGroupFieldSlotName | VireoFormToggleButtonGroupFieldStateName, string>;

export type VireoFormToggleButtonGroupFieldExclusiveProps<TValue extends VireoFormToggleButtonGroupFieldValue> = VireoFormToggleButtonGroupFieldSharedProps<TValue> & {
    multiple?: false;
    onChange?: (event: React.MouseEvent<HTMLElement>, value: TValue | null) => void;
    onValueChange?: (value: TValue | null) => void;
};

export interface VireoFormToggleButtonGroupFieldFormHelperTextSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props inherited from FormControl after excluding form-owned and Vireo-owned props.

/** Props inherited from FormControl after excluding form-owned and Vireo-owned props. */
export type VireoFormToggleButtonGroupFieldInheritedProps = Omit<FormControlProps, ComponentOwnedProp>;

export type VireoFormToggleButtonGroupFieldMultipleProps<TValue extends VireoFormToggleButtonGroupFieldValue> = VireoFormToggleButtonGroupFieldSharedProps<TValue> & {
    multiple: true;
    onChange?: (event: React.MouseEvent<HTMLElement>, value: TValue[]) => void;
    onValueChange?: (value: TValue[]) => void;
};

One ordered choice rendered by `field.ToggleButtonGroupField`.

/** One ordered choice rendered by `field.ToggleButtonGroupField`. */
export type VireoFormToggleButtonGroupFieldOption<TValue extends VireoFormToggleButtonGroupFieldValue> = {
    value: TValue;
    label: React.ReactNode;
    disabled?: boolean;
    /** Accessible name for icon-only or otherwise non-descriptive visible content. */
    ariaLabel?: string;
};

export type VireoFormToggleButtonGroupFieldOptionProps = Omit<ToggleButtonProps, ProtectedToggleButtonProp> & {
    [key: `data-${string}`]: VireoDataAttributeValue;
};

export type VireoFormToggleButtonGroupFieldOptionState = {
    selected: boolean;
    disabled: boolean;
    index: number;
};

export type VireoFormToggleButtonGroupFieldOwnerState = {
    color: NonNullable<ToggleButtonGroupProps["color"]>;
    dirty: boolean;
    disabled: boolean;
    disableClearable: boolean;
    errorVisible: boolean;
    fullWidth: boolean;
    hasValue: boolean;
    invalid: boolean;
    multiple: boolean;
    orientation: NonNullable<ToggleButtonGroupProps["orientation"]>;
    readOnly: boolean;
    required: boolean;
    size: NonNullable<ToggleButtonGroupProps["size"]>;
    submitting: boolean;
    touched: boolean;
    validating: boolean;
};

Props accepted by `field.ToggleButtonGroupField`.

/** Props accepted by `field.ToggleButtonGroupField`. */
export type VireoFormToggleButtonGroupFieldProps<TValue extends VireoFormToggleButtonGroupFieldValue = VireoFormToggleButtonGroupFieldValue> = (VireoFormToggleButtonGroupFieldExclusiveProps<TValue> | VireoFormToggleButtonGroupFieldMultipleProps<TValue>) & VireoFormToggleButtonGroupFieldAccessibleNameProps & VireoFormToggleButtonGroupFieldInheritedProps;

export interface VireoFormToggleButtonGroupFieldRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export type VireoFormToggleButtonGroupFieldSharedProps<TValue extends VireoFormToggleButtonGroupFieldValue> = VireoFormToggleButtonGroupFieldSlotsAndSlotProps & {
    options: readonly VireoFormToggleButtonGroupFieldOption<TValue>[];
    renderOption?: (option: VireoFormToggleButtonGroupFieldOption<TValue>, state: VireoFormToggleButtonGroupFieldOptionState) => React.ReactNode;
    getOptionProps?: (option: VireoFormToggleButtonGroupFieldOption<TValue>, state: VireoFormToggleButtonGroupFieldOptionState) => VireoFormToggleButtonGroupFieldOptionProps;
    classes?: Partial<VireoFormToggleButtonGroupFieldClasses>;
    color?: ToggleButtonGroupProps["color"];
    disabled?: boolean;
    disableClearable?: boolean;
    error?: boolean;
    errorDisplay?: VireoFormErrorDisplay;
    formatError?: VireoFormErrorFormatter;
    /** @default true */
    fullWidth?: boolean;
    /** Defaults to a reserved line; pass `null` to remove it. @default ' ' */
    helperText?: React.ReactNode;
    orientation?: ToggleButtonGroupProps["orientation"];
    readOnly?: boolean;
    readOnlyEmptyValue?: React.ReactNode;
    renderReadOnlyValue?: (value: TValue | readonly TValue[] | null, selectedOptions: readonly VireoFormToggleButtonGroupFieldOption<TValue>[]) => React.ReactNode;
    required?: boolean;
    size?: ToggleButtonGroupProps["size"];
    onBlur?: NonNullable<ToggleButtonGroupProps["onBlur"]>;
    "aria-describedby"?: string;
};

Replaceable semantic regions exposed by the bound toggle-button-group field.

/** Replaceable semantic regions exposed by the bound toggle-button-group field. */
export type VireoFormToggleButtonGroupFieldSlots = {
    root: React.ElementType;
    toggleButtonGroup: React.ElementType;
    toggleButton: React.ElementType;
    formHelperText: React.ElementType;
};

Slot props exposed by the bound toggle-button-group field.

/** Slot props exposed by the bound toggle-button-group field. */
export type VireoFormToggleButtonGroupFieldSlotsAndSlotProps = CreateSlotsAndSlotProps<VireoFormToggleButtonGroupFieldSlots, {
    /** @default FormControl */
    root: SlotProps<typeof FormControl, VireoFormToggleButtonGroupFieldRootSlotPropsOverrides, VireoFormToggleButtonGroupFieldOwnerState>;
    /** @default ToggleButtonGroup */
    toggleButtonGroup: SlotProps<typeof ToggleButtonGroup, VireoFormToggleButtonGroupFieldToggleButtonGroupSlotPropsOverrides, VireoFormToggleButtonGroupFieldOwnerState>;
    /** @default ToggleButton */
    toggleButton: SlotProps<typeof ToggleButton, VireoFormToggleButtonGroupFieldToggleButtonSlotPropsOverrides, VireoFormToggleButtonGroupFieldOwnerState>;
    /** @default FormHelperText */
    formHelperText: SlotProps<typeof FormHelperText, VireoFormToggleButtonGroupFieldFormHelperTextSlotPropsOverrides, VireoFormToggleButtonGroupFieldOwnerState>;
}>;

export interface VireoFormToggleButtonGroupFieldToggleButtonGroupSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoFormToggleButtonGroupFieldToggleButtonSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Scalar option identifiers supported by `field.ToggleButtonGroupField`.

/** Scalar option identifiers supported by `field.ToggleButtonGroupField`. */
export type VireoFormToggleButtonGroupFieldValue = string | number;

export type VireoMultiStepChangeEvent<TStepId extends string = string> = {
    previousStepId: TStepId;
    stepId: TStepId;
    previousStepIndex: number;
    stepIndex: number;
    direction: VireoMultiStepDirection;
    reason: VireoMultiStepChangeReason;
};

export type VireoMultiStepChangeReason = "next" | "previous" | "direct" | "validation-error" | "condition" | "reset";

Metadata describing one stable step in a Vireo multi-step form.

/** Metadata describing one stable step in a Vireo multi-step form. */
export type VireoMultiStepDescriptor<TFormData, TStepId extends string = string> = {
    id: TStepId;
    label: React.ReactNode;
    ariaLabel?: string;
    fields?: readonly DeepKeys<TFormData>[];
    when?: (values: TFormData) => boolean;
};

export type VireoMultiStepDirection = "forward" | "backward";

export type VireoMultiStepFormApi<TFormData, TOnMount extends undefined | FormValidateOrFn<TFormData>, TOnChange extends undefined | FormValidateOrFn<TFormData>, TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnBlur extends undefined | FormValidateOrFn<TFormData>, TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnSubmit extends undefined | FormValidateOrFn<TFormData>, TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnDynamic extends undefined | FormValidateOrFn<TFormData>, TOnDynamicAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>, TSubmitMeta, TStepId extends string> = VireoFormApi<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta> & {
    Form: React.ForwardRefExoticComponent<VireoFormProps & React.RefAttributes<HTMLFormElement>>;
    MultiStep: React.ForwardRefExoticComponent<VireoFormMultiStepProps & React.RefAttributes<HTMLDivElement>>;
    Step: React.ForwardRefExoticComponent<Omit<VireoFormStepProps, "id" | "ref"> & {
        id: TStepId;
    } & React.RefAttributes<HTMLElement>>;
    StepProgress: React.ForwardRefExoticComponent<VireoFormStepProgressProps & React.RefAttributes<HTMLDivElement>>;
    PreviousStepButton: React.ForwardRefExoticComponent<VireoFormPreviousStepButtonProps & React.RefAttributes<HTMLButtonElement>>;
    NextStepButton: React.ForwardRefExoticComponent<VireoFormNextStepButtonProps & React.RefAttributes<HTMLButtonElement>>;
    MultiStepSubscribe: <TSelected = VireoMultiStepState<TStepId>>(props: VireoMultiStepSubscribeProps<TStepId, TSelected>) => React.ReactNode;
    readonly multiStepState: VireoMultiStepState<TStepId>;
    readonly steps: readonly VireoMultiStepStepState<TStepId>[];
    readonly activeSteps: readonly VireoMultiStepStepState<TStepId>[];
    readonly currentStep: VireoMultiStepStepState<TStepId>;
    readonly currentStepId: TStepId;
    readonly currentStepIndex: number;
    readonly activeStepCount: number;
    readonly completedStepCount: number;
    readonly isFirstStep: boolean;
    readonly isLastStep: boolean;
    readonly isStepTransitioning: boolean;
    readonly canGoPrevious: boolean;
    readonly canGoNext: boolean;
    readonly canSubmitCurrentStep: boolean;
    getStepState: (id: TStepId) => VireoMultiStepStepState<TStepId> | undefined;
    goToNextStep: () => Promise<VireoMultiStepNavigationResult<TStepId>>;
    goToPreviousStep: () => Promise<VireoMultiStepNavigationResult<TStepId>>;
    goToStep: (id: TStepId) => Promise<VireoMultiStepNavigationResult<TStepId>>;
};

export type VireoMultiStepNavigationResult<TStepId extends string = string> = {
    status: "changed";
    previousStepId: TStepId;
    stepId: TStepId;
    requestedStepId: TStepId;
    reachedRequestedStep: boolean;
    reason: "next" | "previous" | "direct" | "incomplete-step";
} | {
    status: "invalid";
    stepId: TStepId;
    requestedStepId: TStepId;
    errorPaths: string[];
} | {
    status: "unchanged";
    stepId: TStepId;
    requestedStepId: TStepId;
    reason: "first-step" | "last-step" | "same-step" | "unavailable-step" | "transition-pending";
} | {
    status: "cancelled";
    stepId: TStepId;
    requestedStepId: TStepId;
    reason: "reset" | "step-changed" | "form-unmounted";
};

Reactive public state exposed by a Vireo multi-step form.

/** Reactive public state exposed by a Vireo multi-step form. */
export type VireoMultiStepState<TStepId extends string = string> = {
    steps: readonly VireoMultiStepStepState<TStepId>[];
    activeSteps: readonly VireoMultiStepStepState<TStepId>[];
    currentStep: VireoMultiStepStepState<TStepId>;
    currentStepId: TStepId;
    currentStepIndex: number;
    /** Direction of the most recent current-step change. */
    direction: VireoMultiStepDirection;
    activeStepCount: number;
    completedStepCount: number;
    isFirstStep: boolean;
    isLastStep: boolean;
    isStepTransitioning: boolean;
    canGoPrevious: boolean;
    canGoNext: boolean;
    canSubmitCurrentStep: boolean;
};

export type VireoMultiStepStatus = "upcoming" | "visited" | "complete" | "error";

Public state for one configured multi-step form step.

/** Public state for one configured multi-step form step. */
export type VireoMultiStepStepState<TStepId extends string = string> = {
    id: TStepId;
    label: React.ReactNode;
    ariaLabel?: string;
    fields: readonly string[];
    declaredIndex: number;
    activeIndex: number | null;
    isActive: boolean;
    isCurrent: boolean;
    isVisited: boolean;
    isComplete: boolean;
    hasError: boolean;
    canNavigate: boolean;
    status: VireoMultiStepStatus | null;
};

export type VireoMultiStepSubscribeProps<TStepId extends string, TSelected = VireoMultiStepState<TStepId>> = {
    selector?: (state: VireoMultiStepState<TStepId>) => TSelected;
    children: (selected: TSelected) => React.ReactNode;
};

Coordinates a guarded form across mobile full-screen-dialog and desktop overlay surfaces.

/** Coordinates a guarded form across mobile full-screen-dialog and desktop overlay surfaces. */
export declare const VireoResponsiveFormOverlay: React.ForwardRefExoticComponent<import("./VireoResponsiveFormOverlay.types.js").VireoResponsiveFormOverlaySlotsAndSlotProps & {
    title: React.ReactNode;
    closeLabel: string;
    closeDisabled?: boolean;
    children: React.ReactNode;
    actions?: import("./VireoResponsiveFormOverlay.types.js").VireoResponsiveFormOverlayActions;
    renderForm?: (children: React.ReactNode) => React.ReactNode;
    guardUnsavedChanges?: boolean;
    classes?: Partial<import("./VireoResponsiveFormOverlay.classes.js").VireoResponsiveFormOverlayClasses>;
} & Omit<import("../../../../../../index.js").VireoResponsiveOverlayFrameProps, "aria-label" | "aria-labelledby" | "children" | "classes" | "onClose" | "open" | "slotProps" | "slots" | "title"> & {
    open: boolean;
    onClose: () => void;
} & React.RefAttributes<HTMLDivElement>>;

Guarded actions available to a rendered overlay action row.

/** Guarded actions available to a rendered overlay action row. */
export type VireoResponsiveFormOverlayActionContext = {
    /** Requests closure through close disabling and the current unsaved-changes scope. */
    requestClose: () => void;
};

Static actions or a render callback that receives the guarded close request.

/** Static actions or a render callback that receives the guarded close request. */
export type VireoResponsiveFormOverlayActions = React.ReactNode | ((context: VireoResponsiveFormOverlayActionContext) => React.ReactNode);

export interface VireoResponsiveFormOverlayActionsSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoResponsiveFormOverlayBodySlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Valid keys for VireoResponsiveFormOverlay utility classes and theme style overrides.

/** Valid keys for VireoResponsiveFormOverlay utility classes and theme style overrides. */
export type VireoResponsiveFormOverlayClassKey = keyof VireoResponsiveFormOverlayClasses;

Utility classes available to VireoResponsiveFormOverlay.

/** Utility classes available to VireoResponsiveFormOverlay. */
export type VireoResponsiveFormOverlayClasses = Record<VireoResponsiveFormOverlaySlotName, string>;

export interface VireoResponsiveFormOverlayContentSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

export interface VireoResponsiveFormOverlayHeaderSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Props VireoResponsiveFormOverlay inherits from its default root after excluding component-owned props.

/** Props VireoResponsiveFormOverlay inherits from its default root after excluding component-owned props. */
export type VireoResponsiveFormOverlayInheritedProps = Omit<VireoResponsiveOverlayFrameProps, "aria-label" | "aria-labelledby" | "children" | "classes" | "onClose" | "open" | "slotProps" | "slots" | "title"> & {
    open: boolean;
    onClose: () => void;
};

Props owned by {@link VireoResponsiveFormOverlay }.

/** Props owned by {@link VireoResponsiveFormOverlay}. */
export type VireoResponsiveFormOverlayOwnProps = VireoResponsiveFormOverlaySlotsAndSlotProps & {
    /** Visible overlay heading. */
    title: React.ReactNode;
    /** Accessible label for the close action. */
    closeLabel: string;
    /** Prevents dismissal while a form operation is in progress. @default false */
    closeDisabled?: boolean;
    /** Form content rendered inside the responsive surface. */
    children: React.ReactNode;
    /** Optional persistent action row rendered after the scrolling content. */
    actions?: VireoResponsiveFormOverlayActions;
    /**
     * Wraps the content and action regions in one semantic form boundary.
     * The returned wrapper is normalized to fill the responsive overlay body.
     */
    renderForm?: (children: React.ReactNode) => React.ReactNode;
    /** Whether close requests participate in the nearest unsaved-changes scope. @default true */
    guardUnsavedChanges?: boolean;
    /** Override or extend the utility classes applied to each slot. */
    classes?: Partial<VireoResponsiveFormOverlayClasses>;
};

export type VireoResponsiveFormOverlayOwnerState = {
    open: boolean;
    closeDisabled: boolean;
    hasActions: boolean;
    hasFormWrapper: boolean;
};

Props accepted by {@link VireoResponsiveFormOverlay }.

/** Props accepted by {@link VireoResponsiveFormOverlay}. */
export type VireoResponsiveFormOverlayProps = VireoResponsiveFormOverlayOwnProps & VireoResponsiveFormOverlayInheritedProps;

export interface VireoResponsiveFormOverlayRootSlotPropsOverrides {
    [key: `data-${string}`]: VireoDataAttributeValue;
}

Replaceable semantic regions exposed by {@link VireoResponsiveFormOverlay }.

/** Replaceable semantic regions exposed by {@link VireoResponsiveFormOverlay}. */
export type VireoResponsiveFormOverlaySlots = {
    [TSlotName in VireoResponsiveFormOverlaySlotName]: React.ElementType;
};

Slot props exposed by {@link VireoResponsiveFormOverlay }.

/** Slot props exposed by {@link VireoResponsiveFormOverlay}. */
export type VireoResponsiveFormOverlaySlotsAndSlotProps = CreateSlotsAndSlotProps<VireoResponsiveFormOverlaySlots, {
    /** @default VireoResponsiveOverlayFrame */
    root: SlotProps<typeof VireoResponsiveOverlayFrame, VireoResponsiveFormOverlayRootSlotPropsOverrides, VireoResponsiveFormOverlayOwnerState>;
    /** @default VireoOverlayHeader */
    header: SlotProps<typeof VireoOverlayHeader, VireoResponsiveFormOverlayHeaderSlotPropsOverrides, VireoResponsiveFormOverlayOwnerState>;
    /** @default Box */
    body: SlotProps<typeof Box, VireoResponsiveFormOverlayBodySlotPropsOverrides, VireoResponsiveFormOverlayOwnerState>;
    /** @default DialogContent */
    content: SlotProps<typeof DialogContent, VireoResponsiveFormOverlayContentSlotPropsOverrides, VireoResponsiveFormOverlayOwnerState>;
    /** @default DialogActions */
    actions: SlotProps<typeof DialogActions, VireoResponsiveFormOverlayActionsSlotPropsOverrides, VireoResponsiveFormOverlayOwnerState>;
}>;

export declare const defaultVireoFormErrorSummaryLocaleText: VireoFormErrorSummaryLocaleText;

export declare const defaultVireoFormMultiStepLocaleText: VireoFormMultiStepLocaleText;

Returns the generated utility class name for a VireoFileImagePreview slot or state.

/** Returns the generated utility class name for a VireoFileImagePreview slot or state. */
export declare function getVireoFileImagePreviewUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormActions slot or state.

/** Returns the generated utility class name for a VireoFormActions slot or state. */
export declare function getVireoFormActionsUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormAutocompleteField slot or state.

/** Returns the generated utility class name for a VireoFormAutocompleteField slot or state. */
export declare function getVireoFormAutocompleteFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormAutocompleteMultipleField slot or state.

/** Returns the generated utility class name for a VireoFormAutocompleteMultipleField slot or state. */
export declare function getVireoFormAutocompleteMultipleFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormCheckboxField slot or state.

/** Returns the generated utility class name for a VireoFormCheckboxField slot or state. */
export declare function getVireoFormCheckboxFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormCounterField slot or state.

/** Returns the generated utility class name for a VireoFormCounterField slot or state. */
export declare function getVireoFormCounterFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormErrorSummary slot or state.

/** Returns the generated utility class name for a VireoFormErrorSummary slot or state. */
export declare function getVireoFormErrorSummaryUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormFileField slot or state.

/** Returns the generated utility class name for a VireoFormFileField slot or state. */
export declare function getVireoFormFileFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormFileListField slot or state.

/** Returns the generated utility class name for a VireoFormFileListField slot or state. */
export declare function getVireoFormFileListFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormFreeSoloAutocompleteField slot or state.

/** Returns the generated utility class name for a VireoFormFreeSoloAutocompleteField slot or state. */
export declare function getVireoFormFreeSoloAutocompleteFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormFreeSoloAutocompleteMultipleField slot or state.

/** Returns the generated utility class name for a VireoFormFreeSoloAutocompleteMultipleField slot or state. */
export declare function getVireoFormFreeSoloAutocompleteMultipleFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormMultiStep slot or state.

/** Returns the generated utility class name for a VireoFormMultiStep slot or state. */
export declare function getVireoFormMultiStepUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormNextStepButton slot or state.

/** Returns the generated utility class name for a VireoFormNextStepButton slot or state. */
export declare function getVireoFormNextStepButtonUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormNumberField slot or state.

/** Returns the generated utility class name for a VireoFormNumberField slot or state. */
export declare function getVireoFormNumberFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormPreviousStepButton slot or state.

/** Returns the generated utility class name for a VireoFormPreviousStepButton slot or state. */
export declare function getVireoFormPreviousStepButtonUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormRadioGroupField slot or state.

/** Returns the generated utility class name for a VireoFormRadioGroupField slot or state. */
export declare function getVireoFormRadioGroupFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormReadOnlyValue slot or state.

/** Returns the generated utility class name for a VireoFormReadOnlyValue slot or state. */
export declare function getVireoFormReadOnlyValueUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormSectionItem slot or state.

/** Returns the generated utility class name for a VireoFormSectionItem slot or state. */
export declare function getVireoFormSectionItemUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormSection slot or state.

/** Returns the generated utility class name for a VireoFormSection slot or state. */
export declare function getVireoFormSectionUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormSelectField slot or state.

/** Returns the generated utility class name for a VireoFormSelectField slot or state. */
export declare function getVireoFormSelectFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormSelectMultipleField slot or state.

/** Returns the generated utility class name for a VireoFormSelectMultipleField slot or state. */
export declare function getVireoFormSelectMultipleFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormStepProgress slot or state.

/** Returns the generated utility class name for a VireoFormStepProgress slot or state. */
export declare function getVireoFormStepProgressUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormStep slot or state.

/** Returns the generated utility class name for a VireoFormStep slot or state. */
export declare function getVireoFormStepUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormSubmitButton slot or state.

/** Returns the generated utility class name for a VireoFormSubmitButton slot or state. */
export declare function getVireoFormSubmitButtonUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormSwitchField slot or state.

/** Returns the generated utility class name for a VireoFormSwitchField slot or state. */
export declare function getVireoFormSwitchFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormTemporalField slot or state.

/** Returns the generated utility class name for a VireoFormTemporalField slot or state. */
export declare function getVireoFormTemporalFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormTextField slot or state.

/** Returns the generated utility class name for a VireoFormTextField slot or state. */
export declare function getVireoFormTextFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoFormToggleButtonGroupField slot or state.

/** Returns the generated utility class name for a VireoFormToggleButtonGroupField slot or state. */
export declare function getVireoFormToggleButtonGroupFieldUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoForm slot or state.

/** Returns the generated utility class name for a VireoForm slot or state. */
export declare function getVireoFormUtilityClass(slot: string): string;

Returns the generated utility class name for a VireoResponsiveFormOverlay slot or state.

/** Returns the generated utility class name for a VireoResponsiveFormOverlay slot or state. */
export declare function getVireoResponsiveFormOverlayUtilityClass(slot: string): string;

export declare function useVireoForm<TFormData, TOnMount extends undefined | FormValidateOrFn<TFormData>, TOnChange extends undefined | FormValidateOrFn<TFormData>, TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnBlur extends undefined | FormValidateOrFn<TFormData>, TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnSubmit extends undefined | FormValidateOrFn<TFormData>, TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnDynamic extends undefined | FormValidateOrFn<TFormData>, TOnDynamicAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>, TSubmitMeta>(options: FormOptions<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta>): VireoFormApi<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta>;

Creates one TanStack-backed form with stable, typed multi-step navigation.

/** Creates one TanStack-backed form with stable, typed multi-step navigation. */
export declare function useVireoMultiStepForm<TFormData, TOnMount extends undefined | FormValidateOrFn<TFormData>, TOnChange extends undefined | FormValidateOrFn<TFormData>, TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnBlur extends undefined | FormValidateOrFn<TFormData>, TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnSubmit extends undefined | FormValidateOrFn<TFormData>, TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnDynamic extends undefined | FormValidateOrFn<TFormData>, TOnDynamicAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>, TSubmitMeta, const TSteps extends readonly VireoMultiStepDescriptor<TFormData, string>[]>(options: UseVireoMultiStepFormOptions<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta, TSteps>): VireoMultiStepFormApi<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta, StepId<TSteps>>;

Generated utility class names keyed by each public VireoFileImagePreview class key.

/** Generated utility class names keyed by each public VireoFileImagePreview class key. */
export declare const vireoFileImagePreviewClasses: VireoFileImagePreviewClasses;

Generated utility class names keyed by each public VireoFormActions class key.

/** Generated utility class names keyed by each public VireoFormActions class key. */
export declare const vireoFormActionsClasses: VireoFormActionsClasses;

Generated utility class names keyed by each public VireoFormAutocompleteField class key.

/** Generated utility class names keyed by each public VireoFormAutocompleteField class key. */
export declare const vireoFormAutocompleteFieldClasses: VireoFormAutocompleteFieldClasses;

Generated utility class names keyed by each public VireoFormAutocompleteMultipleField class key.

/** Generated utility class names keyed by each public VireoFormAutocompleteMultipleField class key. */
export declare const vireoFormAutocompleteMultipleFieldClasses: VireoFormAutocompleteMultipleFieldClasses;

Generated utility class names keyed by each public VireoFormCheckboxField class key.

/** Generated utility class names keyed by each public VireoFormCheckboxField class key. */
export declare const vireoFormCheckboxFieldClasses: VireoFormCheckboxFieldClasses;

Generated utility class names keyed by each public VireoForm class key.

/** Generated utility class names keyed by each public VireoForm class key. */
export declare const vireoFormClasses: VireoFormClasses;

Generated utility class names keyed by each public VireoFormCounterField class key.

/** Generated utility class names keyed by each public VireoFormCounterField class key. */
export declare const vireoFormCounterFieldClasses: VireoFormCounterFieldClasses;

Generated utility class names keyed by each public VireoFormErrorSummary class key.

/** Generated utility class names keyed by each public VireoFormErrorSummary class key. */
export declare const vireoFormErrorSummaryClasses: VireoFormErrorSummaryClasses;

Generated utility class names keyed by each public VireoFormFileField class key.

/** Generated utility class names keyed by each public VireoFormFileField class key. */
export declare const vireoFormFileFieldClasses: VireoFormFileFieldClasses;

Generated utility class names keyed by each public VireoFormFileListField class key.

/** Generated utility class names keyed by each public VireoFormFileListField class key. */
export declare const vireoFormFileListFieldClasses: VireoFormFileListFieldClasses;

Generated utility class names keyed by each public VireoFormFreeSoloAutocompleteField class key.

/** Generated utility class names keyed by each public VireoFormFreeSoloAutocompleteField class key. */
export declare const vireoFormFreeSoloAutocompleteFieldClasses: VireoFormFreeSoloAutocompleteFieldClasses;

Generated utility class names keyed by each public VireoFormFreeSoloAutocompleteMultipleField class key.

/** Generated utility class names keyed by each public VireoFormFreeSoloAutocompleteMultipleField class key. */
export declare const vireoFormFreeSoloAutocompleteMultipleFieldClasses: VireoFormFreeSoloAutocompleteMultipleFieldClasses;

Generated utility class names keyed by each public VireoFormMultiStep class key.

/** Generated utility class names keyed by each public VireoFormMultiStep class key. */
export declare const vireoFormMultiStepClasses: VireoFormMultiStepClasses;

Generated utility class names keyed by each public VireoFormNextStepButton class key.

/** Generated utility class names keyed by each public VireoFormNextStepButton class key. */
export declare const vireoFormNextStepButtonClasses: VireoFormNextStepButtonClasses;

Generated utility class names keyed by each public VireoFormNumberField class key.

/** Generated utility class names keyed by each public VireoFormNumberField class key. */
export declare const vireoFormNumberFieldClasses: VireoFormNumberFieldClasses;

Generated utility class names keyed by each public VireoFormPreviousStepButton class key.

/** Generated utility class names keyed by each public VireoFormPreviousStepButton class key. */
export declare const vireoFormPreviousStepButtonClasses: VireoFormPreviousStepButtonClasses;

Generated utility class names keyed by each public VireoFormRadioGroupField class key.

/** Generated utility class names keyed by each public VireoFormRadioGroupField class key. */
export declare const vireoFormRadioGroupFieldClasses: VireoFormRadioGroupFieldClasses;

Generated utility class names keyed by each public VireoFormReadOnlyValue class key.

/** Generated utility class names keyed by each public VireoFormReadOnlyValue class key. */
export declare const vireoFormReadOnlyValueClasses: VireoFormReadOnlyValueClasses;

Generated utility class names keyed by each public VireoFormSection class key.

/** Generated utility class names keyed by each public VireoFormSection class key. */
export declare const vireoFormSectionClasses: VireoFormSectionClasses;

Generated utility class names keyed by each public VireoFormSectionItem class key.

/** Generated utility class names keyed by each public VireoFormSectionItem class key. */
export declare const vireoFormSectionItemClasses: VireoFormSectionItemClasses;

Generated utility class names keyed by each public VireoFormSelectField class key.

/** Generated utility class names keyed by each public VireoFormSelectField class key. */
export declare const vireoFormSelectFieldClasses: VireoFormSelectFieldClasses;

Generated utility class names keyed by each public VireoFormSelectMultipleField class key.

/** Generated utility class names keyed by each public VireoFormSelectMultipleField class key. */
export declare const vireoFormSelectMultipleFieldClasses: VireoFormSelectMultipleFieldClasses;

Generated utility class names keyed by each public VireoFormStep class key.

/** Generated utility class names keyed by each public VireoFormStep class key. */
export declare const vireoFormStepClasses: VireoFormStepClasses;

Generated utility class names keyed by each public VireoFormStepProgress class key.

/** Generated utility class names keyed by each public VireoFormStepProgress class key. */
export declare const vireoFormStepProgressClasses: VireoFormStepProgressClasses;

Generated utility class names keyed by each public VireoFormSubmitButton class key.

/** Generated utility class names keyed by each public VireoFormSubmitButton class key. */
export declare const vireoFormSubmitButtonClasses: VireoFormSubmitButtonClasses;

Generated utility class names keyed by each public VireoFormSwitchField class key.

/** Generated utility class names keyed by each public VireoFormSwitchField class key. */
export declare const vireoFormSwitchFieldClasses: VireoFormSwitchFieldClasses;

Generated utility class names keyed by each public VireoFormTemporalField class key.

/** Generated utility class names keyed by each public VireoFormTemporalField class key. */
export declare const vireoFormTemporalFieldClasses: VireoFormTemporalFieldClasses;

Generated utility class names keyed by each public VireoFormTextField class key.

/** Generated utility class names keyed by each public VireoFormTextField class key. */
export declare const vireoFormTextFieldClasses: VireoFormTextFieldClasses;

Generated utility class names keyed by each public VireoFormToggleButtonGroupField class key.

/** Generated utility class names keyed by each public VireoFormToggleButtonGroupField class key. */
export declare const vireoFormToggleButtonGroupFieldClasses: VireoFormToggleButtonGroupFieldClasses;

Generated utility class names keyed by each public VireoResponsiveFormOverlay class key.

/** Generated utility class names keyed by each public VireoResponsiveFormOverlay class key. */
export declare const vireoResponsiveFormOverlayClasses: VireoResponsiveFormOverlayClasses;