import { ChangeEvent, MouseEventHandler, OptionHTMLAttributes, PropsWithChildren, ReactNode } from "react";
import { FieldAtom, FieldAtomConfig, FormAtom, FormFieldValues, FormFields, RESET, UseAtomOptions, UseFieldOptions, useFieldErrors } from "form-atoms";
import { Atom, ExtractAtomValue, Getter, WritableAtom } from "jotai";
import { ZodAny, ZodArray, ZodBoolean, ZodDate, ZodFile, ZodLiteral, ZodNumber, ZodObject, ZodSchema, ZodString, ZodUndefined, z } from "zod";
import { atomWithDefault } from "jotai/utils";
import { ListAtom, ListAtomConfig } from "@form-atoms/list-atom";
//#region src/atoms/types.d.ts
type ExtendFieldAtom<Value, State> = FieldAtom<Value> extends Atom<infer DefaultState> ? Atom<DefaultState & State> : never;
//#endregion
//#region src/utils/schemaValidate.d.ts
type ValidateConfig<Schema extends z.Schema, OptSchema extends z.Schema> = {
  schema: Schema | ((get: Getter) => Schema);
  optionalSchema?: OptSchema | ((get: Getter) => OptSchema);
};
type DefaultRequiredAtom = typeof defaultRequiredAtom;
type WritableRequiredAtom = WritableAtom<boolean, [boolean | typeof RESET | ((prev: boolean) => boolean)], void>;
/**
 * Read-only atom for default zodFields which all are required.
 */
declare const defaultRequiredAtom: import("jotai").Atom<boolean>;
type ReadRequired = Parameters<typeof atomWithDefault<boolean>>[0];
//#endregion
//#region src/utils/userValidateConfig.d.ts
interface MakeSchema<Schema extends z.Schema> {
  (fieldSchema: Schema): Schema;
  (fieldSchema: Schema, get: Getter): Schema;
}
type UserValidateConfig<Schema extends z.Schema, OptSchema extends z.Schema> = {
  /**
   * User's zod schema, or a function to enhance the initial field schema.
   */
  schema?: Schema | MakeSchema<Schema>;
  optionalSchema?: OptSchema | MakeSchema<OptSchema>;
};
//#endregion
//#region src/fields/zod-field/zodField.d.ts
type ZodFieldConfig<Schema extends z.Schema, OptSchema extends z.Schema = ZodUndefined> = FieldAtomConfig<z.output<Schema> | z.output<OptSchema>> & ValidateConfig<Schema, OptSchema>;
export type ZodFieldValue<Field> = Field extends FieldAtom<infer Value> ? Value : never;
export type ZodFieldSubmitValue<Field> = Field extends ZodField<infer Schema, infer OptSchema, infer Required> ? Required extends WritableRequiredAtom ? z.output<Schema> | z.output<OptSchema> : Required extends DefaultRequiredAtom ? z.output<Schema> : never : never;
export type OptionalZodField<Schema extends z.Schema, OptSchema extends z.Schema = ZodUndefined> = ZodField<Schema, OptSchema, WritableRequiredAtom>;
/**
 * This is an alias to ZodField, it hides the 3rd argument from type tooltip.
 */
export type RequiredZodField<Schema extends z.Schema = ZodAny, OptSchema extends z.Schema = ZodUndefined> = ZodField<Schema, OptSchema>;
export type ZodField<Schema extends z.Schema = ZodAny, OptSchema extends z.Schema = ZodUndefined, RequiredAtom = DefaultRequiredAtom> = ExtendFieldAtom<z.output<Schema> | z.output<OptSchema>, {
  required: RequiredAtom;
}> & {
  optional: (readRequired?: ReadRequired) => OptionalZodField<Schema, OptSchema>;
};
export declare function zodField<Schema extends z.Schema, OptSchema extends z.Schema = ZodUndefined>({ schema, optionalSchema, ...config }: ZodFieldConfig<Schema, OptSchema>): RequiredZodField<Schema, OptSchema>;
//#endregion
//#region src/fields/zod-field/zodParams.d.ts
export type ZodParams = {
  required_error?: string;
};
//#endregion
//#region src/fields/field.d.ts
/**
 * A public config for a field.
 */
type FieldConfig<Schema extends z.Schema, OptSchema extends z.Schema = ZodUndefined> = Partial<FieldAtomConfig<z.output<Schema> | z.output<OptSchema>>> & UserValidateConfig<Schema, OptSchema> & ZodParams;
//#endregion
//#region src/fields/array-field/arrayField.d.ts
export type ZodArrayField<Element extends ZodSchema = ZodAny> = ZodField<ZodArray<Element>, ZodArray<Element>>;
export type ArrayFieldParams<ElementSchema extends z.Schema> = FieldConfig<ZodArray<ElementSchema>, ZodArray<ElementSchema>>;
export declare const arrayField: <ElementSchema extends z.Schema>({ required_error, value, elementSchema, schema, optionalSchema, ...config }: {
  elementSchema: ElementSchema;
} & ArrayFieldParams<ElementSchema>) => RequiredZodField<ZodArray<ElementSchema>, ZodArray<ElementSchema>>;
//#endregion
//#region src/fields/array-field/stringArrayField.d.ts
declare const elementSchema$1: z.ZodString;
export declare const stringArrayField: (params?: Partial<ArrayFieldParams<typeof elementSchema$1>>) => RequiredZodField<z.ZodArray<z.ZodString>, z.ZodArray<z.ZodString>>;
export type StringArrayField = ReturnType<typeof stringArrayField>;
export type StringArrayFieldValue = ExtractAtomValue<ExtractAtomValue<StringArrayField>["value"]>;
//#endregion
//#region src/fields/boolean-field/booleanField.d.ts
export type BooleanField = ReturnType<typeof booleanField>;
export type BooleanFieldValue = ExtractAtomValue<ExtractAtomValue<BooleanField>["value"]>;
export declare const booleanField: ({ required_error, ...config }?: Omit<FieldConfig<ZodBoolean>, "schema" | "optionalSchema">) => RequiredZodField<ZodBoolean, z.ZodUndefined>;
//#endregion
//#region src/fields/checkbox-field/checkboxField.d.ts
export type CheckboxField = ReturnType<typeof checkboxField>;
export type CheckboxFieldValue = ExtractAtomValue<ExtractAtomValue<CheckboxField>["value"]>;
export declare const checkboxField: ({ required_error, value, ...config }?: Partial<Omit<FieldConfig<ZodLiteral<true>, ZodBoolean>, "schema" | "optionalSchema" | "validate">>) => RequiredZodField<ZodLiteral<true>, ZodBoolean>;
//#endregion
//#region src/fields/date-field/dateField.d.ts
export type DateField = ReturnType<typeof dateField>;
export type DateFieldValue = ExtractAtomValue<ExtractAtomValue<DateField>["value"]>;
export declare const dateField: ({ required_error, schema, optionalSchema, ...config }?: FieldConfig<ZodDate>) => RequiredZodField<ZodDate, z.ZodUndefined>;
//#endregion
//#region src/fields/digit-field/digitField.d.ts
export type DigitField = ReturnType<typeof digitField>;
export type DigitFieldValue = ExtractAtomValue<ExtractAtomValue<DigitField>["value"]>;
declare const zodDigitSchema: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>, z.ZodLiteral<7>, z.ZodLiteral<8>, z.ZodLiteral<9>]>;
type ZodDigitSchema = typeof zodDigitSchema;
export declare const digitField: (config?: Omit<FieldConfig<ZodDigitSchema>, "schema" | "optionalSchema">) => RequiredZodField<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>, z.ZodLiteral<7>, z.ZodLiteral<8>, z.ZodLiteral<9>]>, z.ZodUndefined>;
//#endregion
//#region src/fields/files-field/filesField.d.ts
export type FilesField = ReturnType<typeof filesField>;
export type FilesFieldValue = ExtractAtomValue<ExtractAtomValue<FilesField>["value"]>;
export declare const filesField: (params?: Partial<ArrayFieldParams<ZodFile>>) => RequiredZodField<ZodArray<ZodFile>, ZodArray<ZodFile>>;
//#endregion
//#region src/fields/list-field/listField.d.ts
export type ExtendListAtom<Fields extends FormFields, State> = ListAtom<Fields> extends Atom<infer DefaultState> ? Atom<DefaultState & State> : never;
export type ListField<Fields extends FormFields, RequiredAtom = DefaultRequiredAtom> = ExtendListAtom<Fields, {
  required: RequiredAtom;
}> & {
  optional: (readRequired?: ReadRequired) => OptionalListField<Fields>;
};
export type ListFieldSubmitValue<Fields extends FormFields, Required> = Required extends WritableRequiredAtom ? FormFieldSubmitValues<Fields>[] : Required extends DefaultRequiredAtom ? [FormFieldSubmitValues<Fields>, ...FormFieldSubmitValues<Fields>[]] : never;
/**
 * This is an alias to ListField, it hides the 2nd and 3rd argument from type tooltip.
 */
type RequiredListField<Fields extends FormFields> = ListField<Fields, FormFieldValues<Fields>>;
export type OptionalListField<Fields extends FormFields> = ListField<Fields, WritableRequiredAtom>;
type ListFieldConfig<Fields extends FormFields> = ListAtomConfig<Fields> & ZodParams & UserValidateConfig<ZodArray<ZodObject>, ZodArray<ZodObject>>;
export declare const listField: <Fields extends FormFields>({ required_error, schema, optionalSchema, ...config }: ListFieldConfig<Fields>) => RequiredListField<Fields>;
//#endregion
//#region src/fields/number-field/numberField.d.ts
export type NumberField = ReturnType<typeof numberField>;
export type NumberFieldValue = ExtractAtomValue<ExtractAtomValue<NumberField>["value"]>;
export declare const numberField: ({ required_error, schema, optionalSchema, ...config }?: FieldConfig<ZodNumber>) => RequiredZodField<ZodNumber, z.ZodUndefined>;
//#endregion
//#region src/fields/string-field/stringField.d.ts
export type StringField = ReturnType<typeof stringField>;
export type StringFieldValue = ExtractAtomValue<ExtractAtomValue<StringField>["value"]>;
export declare const stringField: ({ required_error, schema, optionalSchema, ...config }?: FieldConfig<ZodString>) => RequiredZodField<ZodString, z.ZodUndefined>;
//#endregion
//#region src/fields/text-field/textField.d.ts
export type TextField = ReturnType<typeof textField>;
export type TextFieldValue = ExtractAtomValue<ExtractAtomValue<TextField>["value"]>;
export declare const textField: ({ required_error, value, schema, optionalSchema, ...config }?: FieldConfig<ZodString, ZodString>) => RequiredZodField<ZodString, ZodString>;
//#endregion
//#region src/hooks/use-checkbox-field-props/useCheckboxFieldProps.d.ts
export type CheckboxFieldProps = FieldProps<CheckboxField | BooleanField>;
export declare function useCheckboxFieldProps(field: CheckboxField | BooleanField, options?: UseFieldOptions<BooleanFieldValue>): {
  type: "checkbox";
  checked: boolean;
  role: "checkbox";
  "aria-checked": boolean;
  id: string;
  name: string | undefined;
  required: boolean;
  "aria-required": boolean;
  "aria-invalid": boolean | undefined;
  ref: (args_0: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | ((value: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) => HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) | null) => void;
  onBlur(): void;
  onChange(event: ChangeEvent<HTMLInputElement>): void;
};
//#endregion
//#region src/hooks/use-field-props/useFieldProps.d.ts
export declare function useFieldProps<Field extends ZodField, Element extends HTMLElement = HTMLInputElement>(fieldAtom: Field, getEventValue: Element extends unknown ? (event: ChangeEvent<Element>, value: ZodFieldValue<Field>) => ZodFieldValue<Field> : never, options?: UseAtomOptions): {
  id: string;
  name: string | undefined;
  value: ZodFieldValue<Field>;
  required: boolean;
  "aria-required": boolean;
  "aria-invalid": boolean | undefined;
  ref: (args_0: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | ((value: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) => HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) | null) => void;
  onBlur(): void;
  onChange(event: ChangeEvent<Element>): void;
};
//#endregion
//#region src/hooks/use-field-props/FieldProps.d.ts
/**
 * Common Props to be used on FieldComponents like CheckboxField or NumberField.
 */
export type FieldProps<Field extends ZodField> = {
  field: Field;
  label?: ReactNode;
  required?: boolean;
} & Pick<UseFieldOptions<ZodFieldValue<Field>>, "initialValue">;
//#endregion
//#region src/hooks/use-multiselect-field-props/useMultiSelectFieldProps.d.ts
export type UseMultiSelectFieldProps<Option, Field extends ZodArrayField> = {
  field: Field;
  getValue: (option: Option) => ZodArrayFieldValue<Field>;
} & Pick<UseOptionsProps<Option>, "options">;
export type ZodArrayFieldValue<Field> = Field extends ZodField<ZodArray<infer Value>, ZodArray<ZodAny>> ? z.infer<Value> : never;
export declare const useMultiSelectFieldProps: <Option, Field extends ZodArrayField>({ field, options, getValue }: UseMultiSelectFieldProps<Option, Field>, { initialValue, ...atomOptions }?: UseFieldOptions<ZodFieldValue<Field>>) => {
  id: string;
  name: string | undefined;
  required: boolean;
  "aria-required": boolean;
  "aria-invalid": boolean | undefined;
  ref: (args_0: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | ((value: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) => HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) | null) => void;
  onBlur(): void;
  onChange(event: ChangeEvent<HTMLSelectElement>): void;
  value: readonly string[];
};
//#endregion
//#region src/hooks/use-options/useOptions.d.ts
export type UseOptionsProps<Option> = {
  field: {
    toString(): string;
  };
  options: readonly Option[];
  getLabel: (option: Option) => ReactNode;
};
export declare function useOptions<Option>({ field, getLabel, options }: UseOptionsProps<Option>): {
  renderOptions: {
    id: string;
    value: number;
    label: ReactNode;
  }[];
};
//#endregion
//#region src/hooks/use-checkbox-group/useCheckboxGroup.d.ts
export type CheckboxGroupFieldProps<Option, Field extends ZodArrayField> = FieldProps<Field> & UseCheckboxGroupProps<Option, Field>;
export type UseCheckboxGroupProps<Option, Field extends ZodArrayField> = UseMultiSelectFieldProps<Option, Field> & UseOptionsProps<Option>;
export declare const useCheckboxGroup: <Option, Field extends ZodArrayField>({ field, getValue, getLabel, options }: UseCheckboxGroupProps<Option, Field>, fieldOptions?: UseFieldOptions<ZodFieldValue<Field>>) => {
  name: string | undefined;
  "aria-required": boolean;
  "aria-invalid": boolean | undefined;
  ref: (args_0: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | ((value: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) => HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) | null) => void;
  onBlur(): void;
  onChange(event: import("react").ChangeEvent<HTMLInputElement>): void;
  id: string;
  value: number;
  label: import("react").ReactNode;
  type: "checkbox";
  required: boolean;
  checked: boolean;
}[];
//#endregion
//#region src/hooks/use-clear-input-action/useClearInputAction.d.ts
export declare const useClearInputAction: <Value>(fieldAtom: FieldAtom<Value>, options?: UseAtomOptions) => {
  clear(): void;
};
//#endregion
//#region src/hooks/use-date-field-props/useDateFieldProps.d.ts
export type DateFieldProps = FieldProps<DateField>;
export declare const useDateFieldProps: (field: DateField, options?: UseFieldOptions<DateFieldValue>) => {
  id: string;
  name: string | undefined;
  value: Date | undefined;
  required: boolean;
  "aria-required": boolean;
  "aria-invalid": boolean | undefined;
  ref: (args_0: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | ((value: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) => HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) | null) => void;
  onBlur(): void;
  onChange(event: ChangeEvent<HTMLInputElement>): void;
  type: "date";
};
//#endregion
//#region src/hooks/use-field-error/useFieldError.d.ts
export declare const useFieldError: <Value>(field: FieldAtom<Value>) => {
  isInvalid: boolean;
  isSuccess: boolean;
  error: string | undefined;
  errors: string[];
};
//#endregion
//#region src/hooks/use-files-field-props/useFilesFieldProps.d.ts
export type FilesFieldProps = Omit<FieldProps<FilesField>, "initialValue">;
export declare const useFilesFieldProps: (field: FilesField, options?: Omit<UseFieldOptions<FilesFieldValue>, "initialValue">) => {
  id: string;
  name: string | undefined;
  required: boolean;
  "aria-required": boolean;
  "aria-invalid": boolean | undefined;
  ref: (args_0: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | ((value: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) => HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) | null) => void;
  onBlur(): void;
  onChange(event: ChangeEvent<HTMLInputElement>): void;
  type: "file";
};
//#endregion
//#region src/hooks/use-number-field-props/useNumberFieldProps.d.ts
export type NumberFieldProps = FieldProps<NumberField>;
export declare const useNumberFieldProps: (field: NumberField, options?: UseFieldOptions<NumberFieldValue>) => {
  id: string;
  name: string | undefined;
  required: boolean;
  "aria-required": boolean;
  "aria-invalid": boolean | undefined;
  ref: (args_0: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | ((value: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) => HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) | null) => void;
  onBlur(): void;
  onChange(event: ChangeEvent<HTMLInputElement>): void;
  value: string | number;
  type: "number";
};
//#endregion
//#region src/hooks/use-required-props/useRequiredProps.d.ts
export type RequiredProps = {
  required: boolean;
  "aria-required": boolean;
};
export declare const useRequiredProps: ({ field, required: manualRequired }: {
  field: ZodField;
  required?: boolean;
}) => {
  required: boolean;
  "aria-required": boolean;
};
export declare const useRequiredActions: (fieldAtom: OptionalZodField<ZodAny>) => {
  setRequired: (args_0: boolean | typeof import("form-atoms").RESET | ((prev: boolean) => boolean)) => void;
};
//#endregion
//#region src/hooks/use-select-field-props/useSelectFieldProps.d.ts
/**
 * This restricts ZodField to have optional schema defaulting to 'undefined of required schema'.
 */
export type SelectField = ZodField;
export type SelectFieldProps<Option, Field extends SelectField> = UseSelectFieldProps<Option, Field> & FieldProps<Field>;
export type UseSelectFieldProps<Option, Field extends SelectField> = {
  field: Field;
  getValue: (option: Option) => NonNullable<ZodFieldValue<Field>>;
} & Pick<UseOptionsProps<Option>, "options">;
/**
 * When field is empty, we map the undefined from data layer to -1 on presentation (UI) layer.
 */
export declare const EMPTY_SELECT_VALUE = -1;
export declare const useSelectFieldProps: <Option, Field extends SelectField>({ field, options, getValue }: UseSelectFieldProps<Option, Field>, { initialValue, ...atomOptions }?: UseFieldOptions<ZodFieldValue<Field>>) => {
  id: string;
  name: string | undefined;
  required: boolean;
  "aria-required": boolean;
  "aria-invalid": boolean | undefined;
  ref: (args_0: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | ((value: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) => HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) | null) => void;
  onBlur(): void;
  onChange(event: ChangeEvent<HTMLInputElement | HTMLSelectElement>): void;
  value: number;
};
//#endregion
//#region src/hooks/use-select-options/useSelectOptions.d.ts
export declare function useSelectOptions<Option>(props: UseOptionsProps<Option>): {
  selectOptions: JSX.Element;
};
//#endregion
//#region src/hooks/use-text-field-props/useTextFieldProps.d.ts
export type TextFieldProps = FieldProps<TextField>;
export declare const useTextFieldProps: (field: TextField, options?: UseFieldOptions<TextFieldValue>) => {
  id: string;
  name: string | undefined;
  value: string;
  required: boolean;
  "aria-required": boolean;
  "aria-invalid": boolean | undefined;
  ref: (args_0: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | ((value: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) => HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null) | null) => void;
  onBlur(): void;
  onChange(event: ChangeEvent<HTMLInputElement | HTMLTextAreaElement>): void;
};
//#endregion
//#region src/components/checkbox-group/CheckboxGroup.d.ts
export type CheckboxGroupProps<Option, Field extends ZodArrayField> = UseCheckboxGroupProps<Option, Field> & Pick<UseFieldOptions<ZodFieldValue<Field>>, "initialValue">;
export declare const CheckboxGroup: <Option, Field extends ZodArrayField>({ field, options, getValue, getLabel, initialValue }: CheckboxGroupProps<Option, Field>) => JSX.Element;
//#endregion
//#region src/components/field-errors/FieldErrors.d.ts
export type FieldErrorsProps<Value> = {
  field: FieldAtom<Value>;
  children?: (props: {
    errors: ReturnType<typeof useFieldErrors>;
  }) => React.ReactElement;
};
export declare function FieldErrors<Value>({ field, children }: FieldErrorsProps<Value>): import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/field-label/FieldLabel.d.ts
type ChildrenProps = PropsWithChildren<{
  htmlFor: string;
  onMouseDown: MouseEventHandler;
}>;
type FieldLabelProps<Field extends FieldAtom<any>> = {
  field: Field;
  label: ReactNode;
  children?: (props: ChildrenProps) => React.ReactElement;
};
/**
 * Renders an accessible label controlling the field's input.
 * @deprecated The atomKey is not suitable for input/label pairing as it does not support SSR. Moreover the onMouseDown is UX feature, not a logic concern for a field.
 */
export declare const FieldLabel: <Field extends FieldAtom<any>>({ field, label, children }: FieldLabelProps<Field>) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/form/FormSubmitValues.d.ts
type Flatten<T> = Identity<{ [K in keyof T]: T[K]; }>;
type Identity<T> = T;
type FormFields$1 = {
  [key: string | number]: FieldAtom<unknown> | ZodField | FormFields$1 | FormFields$1[] | FieldAtom<unknown>[] | ZodField[];
};
export type FormFieldSubmitValues<Fields extends FormFields$1> = Flatten<{ [Key in keyof Fields]: Fields[Key] extends ListField<infer Fields, infer Required> ? ListFieldSubmitValue<Fields, Required> : Fields[Key] extends ZodField ? ZodFieldSubmitValue<Fields[Key]> : Fields[Key] extends FieldAtom<infer Value> ? Value : Fields[Key] extends FormFields$1 ? FormFieldSubmitValues<Fields[Key]> : Fields[Key] extends Array<infer Item> ? Item extends ZodField ? ZodFieldSubmitValue<Fields[Key]>[] : Item extends FieldAtom<infer Value> ? Value[] : Item extends FormFields$1 ? FormFieldSubmitValues<Item>[] : never : never; }>;
export type FormSubmitValues<Form> = Form extends FormAtom<infer Fields> ? FormFieldSubmitValues<Fields> : never;
//#endregion
//#region src/components/multi-select/MultiSelect.d.ts
export type MultiSelectProps<Option, Field extends ZodArrayField> = UseMultiSelectFieldProps<Option, Field> & Omit<UseOptionsProps<Option>, "field"> & Pick<UseFieldOptions<ZodFieldValue<Field>>, "initialValue">;
export declare const MultiSelect: <Option, Field extends ZodArrayField>({ field, getValue, getLabel, options, initialValue }: MultiSelectProps<Option, Field>) => JSX.Element;
//#endregion
//#region src/components/placeholder-option/PlaceholderOption.d.ts
export declare const PlaceholderOption: ({ children, disabled, ...props }: OptionHTMLAttributes<HTMLOptionElement>) => JSX.Element;
//#endregion
//#region src/components/radio-group/RadioGroup.d.ts
export type RadioGroupProps<Option, Field extends SelectField> = SelectFieldProps<Option, Field> & UseOptionsProps<Option>;
export declare const RadioGroup: <Option, Field extends SelectField>({ field, options, getValue, getLabel, initialValue }: RadioGroupProps<Option, Field>) => JSX.Element;
//#endregion
//#region src/components/requirement-indicator/RequirementIndicator.d.ts
export type Props<Field extends ZodField> = {
  field: Field;
  kind?: "icon" | "label";
};
/**
 * Indicates field's required state by using the useRequiredProps() hook.
 */
export declare const RequirementIndicator: <Field extends ZodField>({ kind, field }: Props<Field>) => JSX.Element;
//#endregion
//#region src/components/select/Select.d.ts
export type SelectProps<Option, Field extends SelectField> = SelectFieldProps<Option, Field> & UseOptionsProps<Option> & {
  placeholder?: string;
};
export declare const Select: <Option, Field extends SelectField>({ field, getValue, getLabel, options, placeholder, initialValue }: SelectProps<Option, Field>) => JSX.Element;
//#endregion