@formisch/react 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1073 @@
+import * as v from "valibot";
+import { ChangeEventHandler, FocusEventHandler, FormHTMLAttributes, ReactElement } from "react";
+
+//#region ../../packages/core/dist/index.vanilla.d.ts
+
+//#region src/types/schema.d.ts
+/**
+* Schema type.
+*/
+type Schema = v.GenericSchema | v.GenericSchemaAsync;
+//#endregion
+//#region src/types/signal.d.ts
+/**
+* Signal interface.
+*/
+interface Signal<T> {
+  /**
+  * The value of the signal.
+  */
+  value: T;
+}
+/**
+* Batch interface.
+*/
+
+//#endregion
+//#region src/types/field.d.ts
+/**
+* Field element type.
+*/
+type FieldElement = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
+/**
+* Internal base store interface.
+*/
+interface InternalBaseStore {
+  /**
+  * The kind of field store.
+  */
+  kind: "array" | "object" | "value";
+  /**
+  * The name of the field.
+  */
+  name: string;
+  /**
+  * The schema of the field.
+  */
+  schema: Schema;
+  /**
+  * The initial elements of the field.
+  */
+  initialElements: FieldElement[];
+  /**
+  * The elements of the field.
+  */
+  elements: FieldElement[];
+  /**
+  * The errors of the field.
+  */
+  errors: Signal<[string, ...string[]] | null>;
+  /**
+  * The touched state of the field.
+  */
+  isTouched: Signal<boolean>;
+  /**
+  * The dirty state of the field.
+  */
+  isDirty: Signal<boolean>;
+}
+/**
+* Internal array store interface.
+*/
+interface InternalArrayStore extends InternalBaseStore {
+  /**
+  * The kind of field store.
+  */
+  kind: "array";
+  /**
+  * The children of the array field.
+  */
+  children: InternalFieldStore[];
+  /**
+  * The initial input of the array field.
+  *
+  * Hint: The initial input is used for resetting and may only be changed
+  * during this process. It does not move when a field is moved.
+  */
+  initialInput: Signal<true | null | undefined>;
+  /**
+  * The start input of the array field.
+  *
+  * Hint: The start input is used to determine whether the field is dirty
+  * and moves with it.
+  */
+  startInput: Signal<true | null | undefined>;
+  /**
+  * The input of the array field.
+  *
+  * Hint: The input indicates whether it is `null`, `undefined`, or found in
+  * the children.
+  */
+  input: Signal<true | null | undefined>;
+  /**
+  * The initial items of the array field.
+  *
+  * Hint: The initial items are used for resetting and may only be changed
+  * during this process. It does not move when a field is moved.
+  */
+  initialItems: Signal<string[]>;
+  /**
+  * The start items of the array field.
+  *
+  * Hint: The start items are used to determine whether the field is dirty
+  * and moves with it.
+  */
+  startItems: Signal<string[]>;
+  /**
+  * The items of the array field.
+  */
+  items: Signal<string[]>;
+}
+/**
+* Internal object store interface.
+*/
+interface InternalObjectStore extends InternalBaseStore {
+  /**
+  * The kind of field store.
+  */
+  kind: "object";
+  /**
+  * The children of the object field.
+  */
+  children: Record<string, InternalFieldStore>;
+  /**
+  * The initial input of the object field.
+  *
+  * Hint: The initial input is used for resetting and may only be changed
+  * during this process. It does not move when a field is moved.
+  */
+  initialInput: Signal<true | null | undefined>;
+  /**
+  * The start input of the object field.
+  *
+  * Hint: The start input is used to determine whether the field is dirty
+  * and moves with it.
+  */
+  startInput: Signal<true | null | undefined>;
+  /**
+  * The input of the object field.
+  *
+  * Hint: The input indicates whether it is `null`, `undefined`, or found in
+  * the children.
+  */
+  input: Signal<true | null | undefined>;
+}
+/**
+* Internal value store interface.
+*/
+interface InternalValueStore extends InternalBaseStore {
+  /**
+  * The kind of field store.
+  */
+  kind: "value";
+  /**
+  * The initial input of the value field.
+  *
+  * Hint: The initial input is used for resetting and may only be changed
+  * during this process. It does not move when a field is moved.
+  */
+  initialInput: Signal<unknown>;
+  /**
+  * The start input of the value field.
+  *
+  * Hint: The start input is used to determine whether the field is dirty
+  * and moves with it.
+  */
+  startInput: Signal<unknown>;
+  /**
+  * The input of the value field.
+  */
+  input: Signal<unknown>;
+}
+/**
+* Internal field store type.
+*/
+type InternalFieldStore = InternalArrayStore | InternalObjectStore | InternalValueStore;
+//#endregion
+//#region src/values.d.ts
+/**
+* Internal symbol constant.
+*/
+declare const INTERNAL: "~internal";
+//#endregion
+//#region src/types/utils.d.ts
+/**
+* Checks if a type is `any`.
+*/
+type IsAny<Type> = 0 extends 1 & Type ? true : false;
+/**
+* Checks if a type is `never`.
+*/
+type IsNever<Type> = [Type] extends [never] ? true : false;
+/**
+* Constructs a type that is maybe a promise.
+*/
+type MaybePromise<TValue> = TValue | Promise<TValue>;
+/**
+* Makes all properties deeply optional.
+*/
+type DeepPartial<TValue> = TValue extends readonly unknown[] ? number extends TValue["length"] ? TValue : { [Key in keyof TValue]?: DeepPartial<TValue[Key]> | undefined } : TValue extends Record<PropertyKey, unknown> ? { [Key in keyof TValue]?: DeepPartial<TValue[Key]> | undefined } : TValue | undefined;
+/**
+* Makes all value properties optional.
+*/
+type PartialValues<TValue> = TValue extends readonly unknown[] ? number extends TValue["length"] ? TValue : { [Key in keyof TValue]: PartialValues<TValue[Key]> } : TValue extends Record<PropertyKey, unknown> ? { [Key in keyof TValue]: PartialValues<TValue[Key]> } : TValue | undefined;
+//#endregion
+//#region src/types/form.d.ts
+/**
+* Validation mode type.
+*/
+type ValidationMode = "initial" | "touch" | "input" | "change" | "blur" | "submit";
+/**
+* Form config interface.
+*/
+interface FormConfig<TSchema extends Schema = Schema> {
+  /**
+  * The schema of the form.
+  */
+  readonly schema: TSchema;
+  /**
+  * The initial input of the form.
+  */
+  readonly initialInput?: DeepPartial<v.InferInput<TSchema>> | undefined;
+  /**
+  * The validation mode of the form.
+  */
+  readonly validate?: ValidationMode | undefined;
+  /**
+  * The revalidation mode of the form.
+  */
+  readonly revalidate?: Exclude<ValidationMode, "initial"> | undefined;
+}
+/**
+* Internal form store interface.
+*/
+interface InternalFormStore<TSchema extends Schema = Schema> extends InternalObjectStore {
+  /**
+  * The element of the form.
+  */
+  element?: HTMLFormElement;
+  /**
+  * The number of active validators.
+  */
+  validators: number;
+  /**
+  * The validation mode of the form.
+  */
+  validate: ValidationMode;
+  /**
+  * The revalidation mode of the form.
+  */
+  revalidate: Exclude<ValidationMode, "initial">;
+  /**
+  * The parse function of the form.
+  */
+  parse: (input: unknown) => Promise<v.SafeParseResult<TSchema>>;
+  /**
+  * The submitting state of the form.
+  */
+  isSubmitting: Signal<boolean>;
+  /**
+  * The submitted state of the form.
+  */
+  isSubmitted: Signal<boolean>;
+  /**
+  * The validating state of the form.
+  */
+  isValidating: Signal<boolean>;
+}
+/**
+* Base form store interface.
+*/
+interface BaseFormStore<TSchema extends Schema = Schema> {
+  /**
+  * The internal form store.
+  *
+  * @internal
+  */
+  readonly [INTERNAL]: InternalFormStore<TSchema>;
+}
+/**
+* Submit handler type.
+*/
+type SubmitHandler<TSchema extends Schema> = (output: v.InferOutput<TSchema>, event: SubmitEvent) => MaybePromise<unknown>;
+//#endregion
+//#region src/types/path.d.ts
+/**
+* Path key type.
+*/
+type PathKey = string | number;
+/**
+* Path type.
+*/
+type Path = readonly PathKey[];
+/**
+* Required path type.
+*/
+type RequiredPath = readonly [PathKey, ...Path];
+/**
+* Extracts the exact keys of a tuple, array or object.
+*/
+type KeyOf<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly unknown[] ? number extends TValue["length"] ? number : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? TIndex : never }[number] : TValue extends Record<string, unknown> ? keyof TValue & PathKey : never;
+/**
+* Merges array and object unions into a single object.
+*
+* Hint: This is necessary to make any property accessible. By default,
+* properties that do not exist in all union options are not accessible
+* and result in "any" when accessed.
+*/
+type MergeUnion<T> = { [K in KeyOf<T>]: T extends Record<K, infer V> ? V : never };
+/**
+* Lazily evaluates only the first valid path segment based on the given value.
+*/
+type LazyPath<TValue, TPathToCheck extends Path, TValidPath extends Path = readonly []> = TPathToCheck extends readonly [] ? TValidPath : TPathToCheck extends readonly [infer TFirstKey extends KeyOf<TValue>, ...infer TPathRest extends Path] ? LazyPath<Required<MergeUnion<TValue>[TFirstKey]>, TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<KeyOf<TValue>> extends false ? readonly [...TValidPath, KeyOf<TValue>] : TValidPath;
+/**
+* Returns the path if valid, otherwise the first possible valid path based on
+* the given value.
+*/
+type ValidPath<TValue, TPath extends RequiredPath> = TPath extends LazyPath<Required<TValue>, TPath> ? TPath : LazyPath<Required<TValue>, TPath>;
+/**
+* Extracts the value type at the given path.
+*/
+type PathValue<TValue, TPath extends Path> = TPath extends readonly [infer TKey, ...infer TRest extends Path] ? TKey extends KeyOf<Required<TValue>> ? PathValue<MergeUnion<Required<TValue>>[TKey], TRest> : unknown : TValue;
+/**
+* Checks if a value is an array or contains one.
+*/
+type IsOrHasArray<TValue> = IsAny<TValue> extends true ? false : TValue extends readonly unknown[] ? true : TValue extends Record<string, unknown> ? true extends { [TKey in keyof TValue]: IsOrHasArray<TValue[TKey]> }[keyof TValue] ? true : false : false;
+/**
+* Extracts the exact keys of a tuple, array or object that contain arrays.
+*/
+type KeyOfArrayPath<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly (infer TItem)[] ? number extends TValue["length"] ? IsOrHasArray<TItem> extends true ? number : never : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? IsOrHasArray<NonNullable<TValue[TKey]>> extends true ? TIndex : never : never }[number] : TValue extends Record<string, unknown> ? { [TKey in keyof TValue]: IsOrHasArray<NonNullable<TValue[TKey]>> extends true ? TKey : never }[keyof TValue] & PathKey : never;
+/**
+* Lazily evaluates only the first valid array path segment based on the given value.
+*/
+type LazyArrayPath<TValue, TPathToCheck extends Path, TValidPath extends Path = readonly []> = TPathToCheck extends readonly [] ? TValue extends readonly unknown[] ? TValidPath : readonly [...TValidPath, KeyOfArrayPath<TValue>] : TPathToCheck extends readonly [infer TFirstKey extends KeyOfArrayPath<TValue>, ...infer TPathRest extends Path] ? LazyArrayPath<Required<MergeUnion<TValue>[TFirstKey]>, TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<KeyOfArrayPath<TValue>> extends false ? readonly [...TValidPath, KeyOfArrayPath<TValue>] : never;
+/**
+* Returns the path if valid, otherwise the first possible valid array path
+* based on the given value.
+*/
+type ValidArrayPath<TValue, TPath extends RequiredPath> = TPath extends LazyArrayPath<Required<TValue>, TPath> ? TPath : LazyArrayPath<Required<TValue>, TPath>;
+//#endregion
+//#region src/array/copyItemState/copyItemState.d.ts
+/**
+* Copies the deeply nested state (signal values) from one field store to
+* another. This includes the `elements`, `errors`, `startInput`, `input`,
+* `isTouched`, `isDirty`, and for arrays `startItems` and `items` properties.
+* Recursively walks through the field stores and copies all signal values.
+*
+* @param fromInternalFieldStore The source field store to copy from.
+* @param toInternalFieldStore The destination field store to copy to.
+*/
+//#endregion
+//#region ../../packages/methods/dist/index.vanilla.d.ts
+//#region src/focus/focus.d.ts
+
+/**
+* Focus field config interface.
+*/
+interface FocusFieldConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  /**
+  * The path to the field to focus.
+  */
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+}
+/**
+* Focuses the first input element of a field. This is useful for
+* programmatically setting focus to a specific field, such as after
+* validation errors or user interactions.
+*
+* @param form The form store containing the field.
+* @param config The focus field configuration.
+*/
+declare function focus<TSchema extends Schema, TFieldPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: FocusFieldConfig<TSchema, TFieldPath>): void;
+//#endregion
+//#region src/getAllErrors/getAllErrors.d.ts
+/**
+* Retrieves all error messages from all fields in the form by walking through
+* the entire field store tree. This is useful for displaying a summary of all
+* validation errors across the form.
+*
+* @param form The form store to retrieve errors from.
+*
+* @returns A non-empty array of error messages, or null if no errors exist.
+*/
+declare function getAllErrors(form: BaseFormStore): [string, ...string[]] | null;
+//#endregion
+//#region src/getErrors/getErrors.d.ts
+/**
+* Get form errors config interface.
+*/
+interface GetFormErrorsConfig {
+  /**
+  * The path to a field. Leave undefined to get form-level errors.
+  */
+  readonly path?: undefined;
+}
+/**
+* Get field errors config interface.
+*/
+interface GetFieldErrorsConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  /**
+  * The path to the field to retrieve errors from.
+  */
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+}
+/**
+* Retrieves error messages from the form. When called without a config,
+* returns form-level errors. When called with a path, returns errors for
+* that specific field.
+*
+* @param form The form store to retrieve errors from.
+*
+* @returns A non-empty array of error messages, or null if no errors exist.
+*/
+declare function getErrors<TSchema extends Schema>(form: BaseFormStore<TSchema>): [string, ...string[]] | null;
+/**
+* Retrieves error messages from the form. When called without a config,
+* returns form-level errors. When called with a path, returns errors for
+* that specific field.
+*
+* @param form The form store to retrieve errors from.
+* @param config The get errors configuration.
+*
+* @returns A non-empty array of error messages, or null if no errors exist.
+*/
+declare function getErrors<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? GetFieldErrorsConfig<TSchema, TFieldPath> : GetFormErrorsConfig): [string, ...string[]] | null;
+//#endregion
+//#region src/getInput/getInput.d.ts
+/**
+* Get form input config interface.
+*/
+interface GetFormInputConfig {
+  /**
+  * The path to a field. Leave undefined to get the entire form input.
+  */
+  readonly path?: undefined;
+}
+/**
+* Get field input config interface.
+*/
+interface GetFieldInputConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  /**
+  * The path to the field to retrieve input from.
+  */
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+}
+/**
+* Retrieves the current input value of a specific field or the entire form.
+* Returns a partial object as not all fields may have been set.
+*
+* @param form The form store to retrieve input from.
+*
+* @returns The partial input values of the form or the specified field.
+*/
+declare function getInput<TSchema extends Schema>(form: BaseFormStore<TSchema>): PartialValues<v.InferInput<TSchema>>;
+/**
+* Retrieves the current input value of a specific field or the entire form.
+* Returns a partial object as not all fields may have been set.
+*
+* @param form The form store to retrieve input from.
+* @param config The get input configuration.
+*
+* @returns The partial input values of the form or the specified field.
+*/
+declare function getInput<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? GetFieldInputConfig<TSchema, TFieldPath> : GetFormInputConfig): PartialValues<TFieldPath extends RequiredPath ? PathValue<v.InferInput<TSchema>, TFieldPath> : v.InferInput<TSchema>>;
+//#endregion
+//#region src/handleSubmit/handleSubmit.d.ts
+/**
+* Creates a submit event handler for the form that prevents default browser
+* submission, validates the form input, and calls the provided handler if
+* validation succeeds. This is designed to be used with the form's onsubmit event.
+*
+* @param form The form store to handle submission for.
+* @param handler The submit handler function called with validated output if validation succeeds.
+*
+* @returns A submit event handler function to attach to the form element.
+*/
+declare function handleSubmit<TSchema extends Schema>(form: BaseFormStore<TSchema>, handler: SubmitHandler<TSchema>): (event: SubmitEvent) => Promise<void>;
+//#endregion
+//#region src/insert/insert.d.ts
+/**
+* Insert array field config interface.
+*/
+interface InsertConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  /**
+  * The path to the field array to insert into.
+  */
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  /**
+  * The index to insert the new item at. If undefined, appends to the end.
+  */
+  readonly at?: number | undefined;
+  /**
+  * The partial initial input value for the new item.
+  */
+  readonly initialInput?: DeepPartial<PathValue<v.InferInput<TSchema>, [...TFieldArrayPath, number]>> | undefined;
+}
+/**
+* Inserts a new item into a field array at the specified index. All items at
+* or after the insertion point are shifted up by one index.
+*
+* @param form The form store containing the field array.
+* @param config The insert configuration specifying the path, index, and initial value.
+*/
+declare function insert<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: InsertConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/move/move.d.ts
+/**
+* Move array field config interface.
+*/
+interface MoveConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  /**
+  * The path to the field array to move an item within.
+  */
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  /**
+  * The index of the item to move from.
+  */
+  readonly from: number;
+  /**
+  * The index to move the item to.
+  */
+  readonly to: number;
+}
+/**
+* Moves an item from one index to another within a field array. All items
+* between the source and destination indices are shifted accordingly.
+*
+* @param form The form store containing the field array.
+* @param config The move configuration specifying the path and source/destination indices.
+*/
+declare function move<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: MoveConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/remove/remove.d.ts
+/**
+* Remove array field config interface.
+*/
+interface RemoveConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  /**
+  * The path to the field array to remove an item from.
+  */
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  /**
+  * The index of the item to remove.
+  */
+  readonly at: number;
+}
+/**
+* Removes an item from a field array at the specified index. All items after
+* the removed item are shifted down by one index.
+*
+* @param form The form store containing the field array.
+* @param config The remove configuration specifying the path and index.
+*/
+declare function remove<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: RemoveConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/replace/replace.d.ts
+/**
+* Replace array field config interface.
+*/
+interface ReplaceConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  /**
+  * The path to the field array to replace an item within.
+  */
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  /**
+  * The index of the item to replace.
+  */
+  readonly at: number;
+  /**
+  * The partial initial input value for the replacement item.
+  */
+  readonly initialInput?: DeepPartial<PathValue<v.InferInput<TSchema>, [...TFieldArrayPath, number]>> | undefined;
+}
+/**
+* Replaces an item in a field array at the specified index with new initial input.
+*
+* @param form The form store containing the field array.
+* @param config The replace configuration specifying the path, index, and initial input.
+*/
+declare function replace<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: ReplaceConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/reset/reset.d.ts
+/**
+* Reset base config interface.
+*/
+interface ResetBaseConfig {
+  /**
+  * Whether to keep the current input values during reset. Defaults to false.
+  */
+  readonly keepInput?: boolean | undefined;
+  /**
+  * Whether to keep the touched state during reset. Defaults to false.
+  */
+  readonly keepTouched?: boolean | undefined;
+  /**
+  * Whether to keep the error messages during reset. Defaults to false.
+  */
+  readonly keepErrors?: boolean | undefined;
+}
+/**
+* Reset form config interface.
+*/
+interface ResetFormConfig<TSchema extends Schema> extends ResetBaseConfig {
+  /**
+  * The path to a field. Leave undefined to reset the entire form.
+  */
+  readonly path?: undefined;
+  /**
+  * The new initial input to reset to. If provided, replaces the form's
+  * initial input.
+  */
+  readonly initialInput?: DeepPartial<v.InferInput<TSchema>> | undefined;
+  /**
+  * Whether to keep the submitted state during reset. Defaults to false.
+  */
+  readonly keepSubmitted?: boolean | undefined;
+}
+/**
+* Reset field config interface.
+*/
+interface ResetFieldConfig<TSchema extends Schema, TFieldPath extends RequiredPath> extends ResetBaseConfig {
+  /**
+  * The path to the field to reset.
+  */
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  /**
+  * The new initial input to reset the field to. If provided, replaces the
+  * field's initial input.
+  */
+  readonly initialInput?: DeepPartial<PathValue<v.InferInput<TSchema>, TFieldPath>>;
+}
+/**
+* Resets a specific field or the entire form to its initial state. Provides
+* fine-grained control over which state to preserve during reset through the
+* configuration options.
+*
+* @param form The form store to reset.
+*/
+declare function reset(form: BaseFormStore): void;
+/**
+* Resets a specific field or the entire form to its initial state. Provides
+* fine-grained control over which state to preserve during reset through the
+* configuration options.
+*
+* @param form The form store to reset.
+* @param config The reset configuration specifying what to reset and what to keep.
+*/
+declare function reset<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? ResetFieldConfig<TSchema, TFieldPath> : ResetFormConfig<TSchema>): void;
+//#endregion
+//#region src/setErrors/setErrors.d.ts
+/**
+* Set form errors config interface.
+*/
+interface SetFormErrorsConfig {
+  /**
+  * The path to a field. Leave undefined to set form-level errors.
+  */
+  readonly path?: undefined;
+  /**
+  * The error messages to set, or null to clear errors.
+  */
+  readonly errors: [string, ...string[]] | null;
+}
+/**
+* Set field errors config interface.
+*/
+interface SetFieldErrorsConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  /**
+  * The path to the field to set errors on.
+  */
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  /**
+  * The error messages to set, or null to clear errors.
+  */
+  readonly errors: [string, ...string[]] | null;
+}
+/**
+* Sets or clears error messages on the form or a specific field. This is
+* useful for setting custom validation errors that don't come from schema
+* validation.
+*
+* @param form The form store to set errors on.
+* @param config The set errors configuration specifying the path and error messages.
+*/
+declare function setErrors<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? SetFieldErrorsConfig<TSchema, TFieldPath> : SetFormErrorsConfig): void;
+//#endregion
+//#region src/setInput/setInput.d.ts
+/**
+* Set form input config interface.
+*/
+interface SetFormInputConfig<TSchema extends Schema> {
+  /**
+  * The path to a field. Leave undefined to set the entire form input.
+  */
+  readonly path?: undefined;
+  /**
+  * The input value to set for the form.
+  */
+  readonly input: v.InferInput<TSchema>;
+}
+/**
+* Set field input config interface.
+*/
+interface SetFieldInputConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  /**
+  * The path to the field to set input on.
+  */
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  /**
+  * The input value to set for the field.
+  */
+  readonly input: PathValue<v.InferInput<TSchema>, TFieldPath>;
+}
+/**
+* Sets the input value of a specific field or the entire form. This updates
+* the field value(s) and triggers validation if required by the form's
+* validation mode.
+*
+* @param form The form store to set input on.
+* @param config The set form input configuration specifying the new input values.
+*/
+declare function setInput<TSchema extends Schema>(form: BaseFormStore<TSchema>, config: SetFormInputConfig<TSchema>): void;
+/**
+* Sets the input value of a specific field or the entire form. This updates
+* the field value(s) and triggers validation if required by the form's
+* validation mode.
+*
+* @param form The form store to set input on.
+* @param config The set input configuration specifying the path and new value.
+*/
+declare function setInput<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? SetFieldInputConfig<TSchema, TFieldPath> : SetFormInputConfig<TSchema>): void;
+//#endregion
+//#region src/submit/submit.d.ts
+/**
+* Programmatically requests form submission by calling the native
+* `requestSubmit()` method on the underlying form element.
+*
+* @param form The form store to submit.
+*/
+declare function submit(form: BaseFormStore): void;
+//#endregion
+//#region src/swap/swap.d.ts
+/**
+* Swap array field config interface.
+*/
+interface SwapConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  /**
+  * The path to the field array to swap items within.
+  */
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  /**
+  * The index of the first item to swap.
+  */
+  readonly at: number;
+  /**
+  * The index of the second item to swap with the first.
+  */
+  readonly and: number;
+}
+/**
+* Swaps two items in a field array by exchanging their positions.
+*
+* @param form The form store containing the field array.
+* @param config The swap configuration specifying the path and indices to swap.
+*/
+declare function swap<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: SwapConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/validate/validate.d.ts
+/**
+* Validate form config interface.
+*/
+interface ValidateFormConfig {
+  /**
+  * Whether to focus the first field with errors after validation. Defaults to false.
+  */
+  readonly shouldFocus?: boolean | undefined;
+}
+/**
+* Validates the entire form input against its schema. Returns a safe parse result
+* indicating success or failure with detailed issues. Optionally focuses the first
+* field with validation errors.
+*
+* @param form The form store to validate.
+* @param config The validate form configuration specifying focus behavior.
+*
+* @returns A promise resolving to the validation result.
+*/
+declare function validate<TSchema extends Schema>(form: BaseFormStore<TSchema>, config?: ValidateFormConfig): Promise<v.SafeParseResult<TSchema>>;
+//#endregion
+//#endregion
+//#region src/types/field.d.ts
+/**
+* Field element props interface.
+*/
+interface FieldElementProps {
+  /**
+  * The name attribute of the field element.
+  */
+  readonly name: string;
+  /**
+  * Whether to autofocus the field element when there are errors.
+  */
+  readonly autoFocus: boolean;
+  /**
+  * The ref callback to register the field element.
+  */
+  readonly ref: (element: FieldElement | null) => void;
+  /**
+  * The focus event handler of the field element.
+  */
+  readonly onFocus: FocusEventHandler<FieldElement>;
+  /**
+  * The change event handler of the field element.
+  */
+  readonly onChange: ChangeEventHandler<FieldElement>;
+  /**
+  * The blur event handler of the field element.
+  */
+  readonly onBlur: FocusEventHandler<FieldElement>;
+}
+/**
+* Field store interface.
+*/
+interface FieldStore<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
+  /**
+  * The path to the field within the form.
+  */
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  /**
+  * The current input value of the field.
+  */
+  readonly input: PartialValues<PathValue<v.InferInput<TSchema>, TFieldPath>>;
+  /**
+  * The current error messages of the field.
+  */
+  readonly errors: [string, ...string[]] | null;
+  /**
+  * Whether the field has been touched.
+  */
+  readonly isTouched: boolean;
+  /**
+  * Whether the field input differs from its initial value.
+  */
+  readonly isDirty: boolean;
+  /**
+  * Whether the field is valid according to the schema.
+  */
+  readonly isValid: boolean;
+  /**
+  * The props to spread onto the field element for integration.
+  */
+  readonly props: FieldElementProps;
+}
+/**
+* Field array store interface.
+*/
+interface FieldArrayStore<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
+  /**
+  * The path to the array field within the form.
+  */
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  /**
+  * The item IDs of the array field.
+  */
+  readonly items: string[];
+  /**
+  * The current error messages of the field array.
+  */
+  readonly errors: [string, ...string[]] | null;
+  /**
+  * Whether the field array has been touched.
+  */
+  readonly isTouched: boolean;
+  /**
+  * Whether the field array input differs from its initial value.
+  */
+  readonly isDirty: boolean;
+  /**
+  * Whether the field array is valid according to the schema.
+  */
+  readonly isValid: boolean;
+}
+//#endregion
+//#region src/types/form.d.ts
+/**
+* Form store interface.
+*/
+interface FormStore<TSchema extends Schema = Schema> extends BaseFormStore<TSchema> {
+  /**
+  * Whether the form is currently submitting.
+  */
+  readonly isSubmitting: boolean;
+  /**
+  * Whether the form has been submitted.
+  */
+  readonly isSubmitted: boolean;
+  /**
+  * Whether the form is currently validating.
+  */
+  readonly isValidating: boolean;
+  /**
+  * Whether any field in the form has been touched.
+  */
+  readonly isTouched: boolean;
+  /**
+  * Whether any field in the form differs from its initial value.
+  */
+  readonly isDirty: boolean;
+  /**
+  * Whether the form is valid according to the schema.
+  */
+  readonly isValid: boolean;
+  /**
+  * The current error messages of the form.
+  *
+  * Hint: This property only contains validation errors at the root level
+  * of the form. To get all errors from all fields, use `getAllErrors`.
+  */
+  readonly errors: [string, ...string[]] | null;
+}
+//#endregion
+//#region src/components/Field/Field.d.ts
+/**
+* Field component props interface.
+*/
+interface FieldProps<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
+  /**
+  * The form store to which the field belongs.
+  */
+  readonly of: FormStore<TSchema>;
+  /**
+  * The path to the field within the form schema.
+  */
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  /**
+  * The render function that receives the field store and returns JSX.
+  */
+  readonly children: (store: FieldStore<TSchema, TFieldPath>) => ReactElement;
+}
+/**
+* Headless form field component that provides reactive properties and state.
+* The field component takes a form store, path to field, and a render function
+* that receives a field store to display field state and handle user interactions.
+*
+* @param props The field component props.
+*
+* @returns The UI of the field to be rendered.
+*/
+declare function Field<TSchema extends Schema, TFieldPath extends RequiredPath>({
+  of,
+  path,
+  children
+}: FieldProps<TSchema, TFieldPath>): ReactElement;
+//#endregion
+//#region src/components/FieldArray/FieldArray.d.ts
+/**
+* FieldArray component props interface.
+*/
+interface FieldArrayProps<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
+  /**
+  * The form store to which the field array belongs.
+  */
+  readonly of: FormStore<TSchema>;
+  /**
+  * The path to the field array within the form schema.
+  */
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  /**
+  * The render function that receives the field array store and returns JSX.
+  */
+  readonly children: (store: FieldArrayStore<TSchema, TFieldArrayPath>) => ReactElement;
+}
+/**
+* Headless field array component that provides reactive properties and state.
+* The field array component takes a form store, path to array field, and a render
+* function that receives a field array store to manage array items and handle
+* array operations.
+*
+* @param props The field array component props.
+*
+* @returns The UI of the field array to be rendered.
+*/
+declare function FieldArray<TSchema extends Schema, TFieldArrayPath extends RequiredPath>({
+  of,
+  path,
+  children
+}: FieldArrayProps<TSchema, TFieldArrayPath>): ReactElement;
+//#endregion
+//#region src/components/Form/Form.d.ts
+/**
+* Form component props type.
+*/
+type FormProps<TSchema extends Schema = Schema> = Omit<FormHTMLAttributes<HTMLFormElement>, "onSubmit" | "novalidate" | "noValidate"> & {
+  /**
+  * The form store instance.
+  */
+  readonly of: FormStore<TSchema>;
+  /**
+  * The submit handler called when the form is submitted and validation succeeds.
+  */
+  readonly onSubmit: SubmitHandler<TSchema>;
+};
+/**
+* Form component that manages form submission and applies internal state.
+* Wraps form element and passes submission events to the provided handler.
+*
+* @param props The form component props.
+*
+* @returns The a native form element.
+*/
+declare function Form<TSchema extends Schema>(props: FormProps<TSchema>): ReactElement;
+//#endregion
+//#region src/hooks/useField/useField.d.ts
+/**
+* Use field config interface.
+*/
+interface UseFieldConfig<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
+  /**
+  * The path to the field within the form schema.
+  */
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+}
+/**
+* Creates a reactive field store of a specific field within a form store.
+*
+* @param form The form store instance.
+* @param config The field configuration.
+*
+* @returns The field store with reactive properties and element props.
+*/
+declare function useField<TSchema extends Schema, TFieldPath extends RequiredPath>(form: FormStore<TSchema>, config: UseFieldConfig<TSchema, TFieldPath>): FieldStore<TSchema, TFieldPath>;
+//#endregion
+//#region src/hooks/useFieldArray/useFieldArray.d.ts
+/**
+* Use field array config interface.
+*/
+interface UseFieldArrayConfig<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
+  /**
+  * The path to the array field within the form schema.
+  */
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+}
+/**
+* Creates a reactive field array store of a specific field array within a form store.
+*
+* @param form The form store instance.
+* @param config The field array configuration.
+*
+* @returns The field array store with reactive properties for array management.
+*/
+declare function useFieldArray<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: FormStore<TSchema>, config: UseFieldArrayConfig<TSchema, TFieldArrayPath>): FieldArrayStore<TSchema, TFieldArrayPath>;
+//#endregion
+//#region src/hooks/useForm/useForm.d.ts
+/**
+* Creates a reactive form store from a form configuration. The form store
+* manages form state and provides reactive properties.
+*
+* @param config The form configuration.
+*
+* @returns The form store with reactive properties.
+*/
+declare function useForm<TSchema extends Schema>(config: FormConfig<TSchema>): FormStore<TSchema>;
+//#endregion
+export { type DeepPartial, Field, FieldArray, FieldArrayProps, FieldArrayStore, type FieldElement, FieldElementProps, FieldProps, FieldStore, FocusFieldConfig, Form, type FormConfig, FormProps, FormStore, GetFieldErrorsConfig, GetFieldInputConfig, GetFormErrorsConfig, GetFormInputConfig, InsertConfig, MoveConfig, type PartialValues, type PathValue, RemoveConfig, ReplaceConfig, type RequiredPath, ResetFieldConfig, ResetFormConfig, type Schema, SetFieldErrorsConfig, SetFieldInputConfig, SetFormErrorsConfig, SetFormInputConfig, type SubmitHandler, SwapConfig, UseFieldArrayConfig, UseFieldConfig, type ValidArrayPath, type ValidPath, ValidateFormConfig, type ValidationMode, focus, getAllErrors, getErrors, getInput, handleSubmit, insert, move, remove, replace, reset, setErrors, setInput, submit, swap, useField, useFieldArray, useForm, validate };