# Formisch

> The lightweight, schema-first and fully type-safe form library for Angular, Preact, Qwik, React, React Native, Solid, Svelte and Vue.

## Hooks

### useForm

Creates a reactive form store from a form configuration. The form store manages form state and provides reactive properties.

```ts
const form = useForm<TSchema>(config);
```

#### Generics

- `TSchema` `extends FormSchema`

#### Parameters

- `config` `FormConfig<TSchema>`

##### Explanation

`useForm` creates a reactive form store that manages form state using the provided Valibot schema. Validation runs when the form is submitted by default, after which fields revalidate on every input, but this can be customized with the `validate` and `revalidate` options.

Since React Native has no native form element or submit event, there is no `<Form />` component. Instead, submission is triggered explicitly with the [`handleSubmit`](/methods/api/handleSubmit.md) method, for example from a button's `onPress` or a text input's `onSubmitEditing` handler.

#### Returns

- `form` `FormStore<TSchema>`

#### Examples

The following examples show how `useForm` can be used.

##### Login screen

```tsx
import { Field, handleSubmit, useForm } from '@formisch/react-native';
import { Button, Text, TextInput, View } from 'react-native';
import * as v from 'valibot';

const LoginSchema = v.object({
  email: v.pipe(v.string(), v.email()),
  password: v.pipe(v.string(), v.minLength(8)),
});

export default function LoginScreen() {
  const loginForm = useForm({
    schema: LoginSchema,
  });

  const submitForm = handleSubmit(loginForm, (output) => console.log(output));

  return (
    <View>
      <Field of={loginForm} path={['email']}>
        {(field) => (
          <View>
            <TextInput {...field.props} value={field.input} />
            {field.errors && <Text>{field.errors[0]}</Text>}
          </View>
        )}
      </Field>
      <Field of={loginForm} path={['password']}>
        {(field) => (
          <View>
            <TextInput {...field.props} value={field.input} secureTextEntry />
            {field.errors && <Text>{field.errors[0]}</Text>}
          </View>
        )}
      </Field>
      <Button title="Login" onPress={submitForm} />
    </View>
  );
}
```

##### Initial input

```ts
const profileForm = useForm({
  schema: ProfileSchema,
  initialInput: {
    name: 'Jane Doe',
    email: 'jane@example.com',
  },
});
```

##### Validation timing

```ts
const signUpForm = useForm({
  schema: SignUpSchema,
  validate: 'blur',
  revalidate: 'input',
});
```

#### Related

The following APIs can be combined with `useForm`.

##### Hooks

[`useField`](/react-native/api/useField.md), [`useFieldArray`](/react-native/api/useFieldArray.md)

##### Components

[`Field`](/react-native/api/Field.md), [`FieldArray`](/react-native/api/FieldArray.md)

##### Methods

[`focus`](/methods/api/focus.md), [`getDeepErrors`](/methods/api/getDeepErrors.md), [`getErrors`](/methods/api/getErrors.md), [`getInput`](/methods/api/getInput.md), [`handleSubmit`](/methods/api/handleSubmit.md), [`insert`](/methods/api/insert.md), [`move`](/methods/api/move.md), [`remove`](/methods/api/remove.md), [`replace`](/methods/api/replace.md), [`reset`](/methods/api/reset.md), [`setErrors`](/methods/api/setErrors.md), [`setInput`](/methods/api/setInput.md), [`swap`](/methods/api/swap.md), [`validate`](/methods/api/validate.md)

### useField

Creates a reactive field store of a specific field within a form store.

```ts
const field = useField<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Parameters

- `form` `FormStore<TSchema>`
- `config` `UseFieldConfig<TSchema, TFieldPath>`

##### Explanation

With `useField` you create a reactive field store for a specific field path within your form. The field store provides reactive access to the field's input value, validation errors, touched state, and more. It also includes a `props` object that you can spread onto React Native's `TextInput` component to automatically handle user interactions like focus, blur, and text change events.

The `props` object contains exactly a `ref` callback and `onFocus`, `onBlur` and `onChangeText` handlers. The `ref` callback registers the underlying native component instance, which enables methods like [`focus`](/methods/api/focus.md) to control it. Since `props` does not set the input value, text inputs are controlled and you always pass `value={field.input}`. For non-text components such as `Switch`, set the value with the field store's `onChange` method instead.

#### Returns

- `field` `FieldStore<TSchema, TFieldPath>`
  - `props` `FieldElementProps`

#### Examples

The following examples show how `useField` can be used.

##### Text field

```tsx
import { useField, useForm } from '@formisch/react-native';
import { Text, TextInput, View } from 'react-native';
import * as v from 'valibot';

const LoginSchema = v.object({
  email: v.pipe(v.string(), v.email()),
});

export default function LoginScreen() {
  const loginForm = useForm({ schema: LoginSchema });
  const field = useField(loginForm, { path: ['email'] });

  return (
    <View>
      <TextInput {...field.props} value={field.input} />
      {field.errors && <Text>{field.errors[0]}</Text>}
    </View>
  );
}
```

##### Non-text components

```tsx
import { useField, useForm } from '@formisch/react-native';
import { Switch } from 'react-native';
import * as v from 'valibot';

const SettingsSchema = v.object({
  notifications: v.optional(v.boolean(), false),
});

export default function SettingsScreen() {
  const settingsForm = useForm({ schema: SettingsSchema });
  const field = useField(settingsForm, { path: ['notifications'] });

  return <Switch value={field.input} onValueChange={field.onChange} />;
}
```

#### Related

The following APIs can be combined with `useField`.

##### Hooks

[`useForm`](/react-native/api/useForm.md), [`useFieldArray`](/react-native/api/useFieldArray.md)

##### Components

[`Field`](/react-native/api/Field.md), [`FieldArray`](/react-native/api/FieldArray.md)

##### Methods

[`focus`](/methods/api/focus.md), [`getErrors`](/methods/api/getErrors.md), [`getInput`](/methods/api/getInput.md), [`setErrors`](/methods/api/setErrors.md), [`setInput`](/methods/api/setInput.md), [`validate`](/methods/api/validate.md)

### useFieldArray

Creates a reactive field array store of a specific field array within a form store.

```ts
const fieldArray = useFieldArray<TSchema, TFieldArrayPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldArrayPath` `extends RequiredPath`

#### Parameters

- `form` `FormStore<TSchema>`
- `config` `UseFieldArrayConfig<TSchema, TFieldArrayPath>`

##### Explanation

With `useFieldArray` you create a reactive field array store for a specific array field within your form. The field array store provides reactive access to the array items (by their IDs), validation errors, touched state, and more. This is particularly useful when working with dynamic arrays of fields that users can add or remove. Use the item IDs as the `key` when mapping over the array items.

#### Returns

- `fieldArray` `FieldArrayStore<TSchema, TFieldArrayPath>`

#### Examples

The following example shows how `useFieldArray` can be used.

##### Todo list

```tsx
import {
  Field,
  insert,
  remove,
  useFieldArray,
  useForm,
} from '@formisch/react-native';
import { Button, Text, TextInput, View } from 'react-native';
import * as v from 'valibot';

const TodoSchema = v.object({
  todos: v.array(
    v.object({
      label: v.pipe(v.string(), v.nonEmpty()),
    })
  ),
});

export default function TodosScreen() {
  const todoForm = useForm({ schema: TodoSchema });
  const fieldArray = useFieldArray(todoForm, { path: ['todos'] });

  return (
    <View>
      {fieldArray.items.map((item, index) => (
        <View key={item}>
          <Field of={todoForm} path={['todos', index, 'label']}>
            {(field) => (
              <View>
                <TextInput {...field.props} value={field.input} />
                {field.errors && <Text>{field.errors[0]}</Text>}
              </View>
            )}
          </Field>
          <Button
            title="Remove"
            onPress={() => remove(todoForm, { path: ['todos'], at: index })}
          />
        </View>
      ))}
      {fieldArray.errors && <Text>{fieldArray.errors[0]}</Text>}
      <Button
        title="Add todo"
        onPress={() =>
          insert(todoForm, { path: ['todos'], initialInput: { label: '' } })
        }
      />
    </View>
  );
}
```

#### Related

The following APIs can be combined with `useFieldArray`.

##### Hooks

[`useForm`](/react-native/api/useForm.md), [`useField`](/react-native/api/useField.md)

##### Components

[`Field`](/react-native/api/Field.md), [`FieldArray`](/react-native/api/FieldArray.md)

##### Methods

[`focus`](/methods/api/focus.md), [`getDeepErrors`](/methods/api/getDeepErrors.md), [`getErrors`](/methods/api/getErrors.md), [`getInput`](/methods/api/getInput.md), [`insert`](/methods/api/insert.md), [`move`](/methods/api/move.md), [`remove`](/methods/api/remove.md), [`replace`](/methods/api/replace.md), [`reset`](/methods/api/reset.md), [`setErrors`](/methods/api/setErrors.md), [`setInput`](/methods/api/setInput.md), [`swap`](/methods/api/swap.md), [`validate`](/methods/api/validate.md)

## Components

### Field

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.

```tsx
<Field of={…} path={…}>children</Field>
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Properties

- `of` `FormStore<TSchema>`
- `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`
- `children` `(store: FieldStore<TSchema, TFieldPath>) => ReactElement`

##### Explanation

The `Field` component is a headless component that doesn't render any UI itself. Instead, it provides a render prop function via the `children` prop that receives a [`FieldStore`](/react-native/api/FieldStore.md) containing all the reactive state and props needed to render a form field.

The component automatically handles field registration, validation, and state management through the `of` prop that references the form store.

#### Related

##### Hooks

[`useForm`](/react-native/api/useForm.md), [`useField`](/react-native/api/useField.md)

##### Components

[`FieldArray`](/react-native/api/FieldArray.md)

### FieldArray

Headless field array component that provides reactive properties and state for managing array fields. 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.

```tsx
<FieldArray of={…} path={…}>children</FieldArray>
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldArrayPath` `extends RequiredPath`

#### Properties

- `of` `FormStore<TSchema>`
- `path` `ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>`
- `children` `(store: FieldArrayStore<TSchema, TFieldArrayPath>) => ReactElement`

##### Explanation

The `FieldArray` component is a headless component that doesn't render any UI itself. Instead, it provides a render prop function via the `children` prop that receives a [`FieldArrayStore`](/react-native/api/FieldArrayStore.md) containing the reactive state of the array field, such as its item IDs and validation errors. The items themselves are manipulated with the form methods listed below.

The component automatically handles array field registration, validation, and state management through the `of` prop that references the form store.

#### Related

##### Hooks

[`useForm`](/react-native/api/useForm.md), [`useFieldArray`](/react-native/api/useFieldArray.md)

##### Components

[`Field`](/react-native/api/Field.md)

##### Methods

[`insert`](/methods/api/insert.md), [`move`](/methods/api/move.md), [`remove`](/methods/api/remove.md), [`replace`](/methods/api/replace.md), [`swap`](/methods/api/swap.md)

## Methods

### focus

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.

```ts
focus<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `FocusFieldConfig<TSchema, TFieldPath>`

##### Explanation

The `form` parameter is the form store containing the field to focus. The `config` parameter specifies which field to focus using the `path` property, and can optionally include additional focus options.

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`validate`](/methods/api/validate.md), [`setErrors`](/methods/api/setErrors.md)

### getDeepErrorEntries

Retrieves the errors of a specific field or the entire form as a list of entries, each pairing the path to a field with its error messages. This is useful for building custom error summaries that link each message back to its field.

```ts
const entries = getDeepErrorEntries<TSchema>(form);
const entries = getDeepErrorEntries<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath | undefined = undefined`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `GetFormDeepErrorEntriesConfig | GetFieldDeepErrorEntriesConfig<TSchema, TFieldPath> | undefined`

##### Explanation

The `form` parameter is the form store to retrieve error entries from. The optional `config` parameter scopes the collection to a specific field's subtree via a `path` (when omitted, the entire form is walked). Each returned entry contains the `path` to a field and its non-empty list of `errors`.

#### Returns

- `result` `DeepErrorEntry[]`

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`getErrors`](/methods/api/getErrors.md), [`getDeepErrors`](/methods/api/getDeepErrors.md), [`validate`](/methods/api/validate.md)

### getDeepErrors

Retrieves all error messages of a specific field or the entire form by walking through the field store and all its descendants. This is useful for displaying a summary of all validation errors within a section or the whole form.

```ts
const errors = getDeepErrors<TSchema>(form);
const errors = getDeepErrors<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath | undefined = undefined`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `GetFormDeepErrorsConfig | GetFieldDeepErrorsConfig<TSchema, TFieldPath> | undefined`

##### Explanation

The `form` parameter is the form store to retrieve errors from. The optional `config` parameter scopes the collection to a specific field's subtree via a `path` (when omitted, the entire form is walked). The function walks through the field store and all its descendants to collect every validation error message.

#### Returns

- `result` `[string, ...string[]] | null`

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`getErrors`](/methods/api/getErrors.md), [`getDeepErrorEntries`](/methods/api/getDeepErrorEntries.md), [`validate`](/methods/api/validate.md), [`setErrors`](/methods/api/setErrors.md)

### getDirtyInput

Retrieves only the dirty input values of a specific field or the entire form. Object keys whose subtree contains no dirty descendant are omitted; arrays are treated as atomic and returned in full whenever any descendant is dirty. Returns `undefined` if no field in the inspected subtree is dirty.

```ts
const input = getDirtyInput<TSchema>(form);
const input = getDirtyInput<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath | undefined = undefined`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `GetFormDirtyInputConfig | GetFieldDirtyInputConfig<TSchema, RequiredPath> | undefined`

##### Explanation

The `form` parameter is the form store to retrieve dirty input from. The optional `config` parameter scopes the result to a specific field path - if omitted, returns dirty input from the entire form. The returned value is a partial of the inspected input shape containing only the fields whose `isDirty` flag is set, which is useful for submitting only the values that changed since the start input. Arrays are treated as atomic — when any descendant of an array is dirty, the full current array is returned.

Internally, the function walks the form's field tree and asks `getFieldBool` whether each branch contains a dirty descendant. Because that check is itself recursive, the cost is effectively linear in field count for typical balanced forms (shallow and wide) and degrades toward `O(N²)` for deeply nested trees. Call this method from submit or blur handlers rather than from tight reactive loops on large forms.

#### Returns

- `result` `DeepPartial<v.InferInput<TSchema>> | undefined`

#### Related

##### Methods

[`getDirtyPaths`](/methods/api/getDirtyPaths.md), [`getInput`](/methods/api/getInput.md), [`pickDirty`](/methods/api/pickDirty.md), [`reset`](/methods/api/reset.md)

### getDirtyPaths

Returns a list of paths to dirty fields in the form. Object branches are recursed into; arrays are treated as atomic — when any descendant of an array is dirty, only the array's own path is returned.

```ts
const paths = getDirtyPaths<TSchema>(form);
const paths = getDirtyPaths<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath | undefined = undefined`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `GetFormDirtyPathsConfig | GetFieldDirtyPathsConfig<TSchema, RequiredPath> | undefined`

##### Explanation

The `form` parameter is the form store to inspect. The optional `config` parameter scopes the search to a single subtree via its `path` property. Object branches are recursed into and clean keys are omitted; arrays are atomic, so when any descendant of an array is dirty, the result includes the array's own path rather than the paths of its individual items. Returns an empty array if the inspected subtree contains no dirty fields. When `path` targets a dirty array or value field, the result contains that path.

Internally, the function walks the form's field tree and asks `getFieldBool` whether each branch contains a dirty descendant. Because that check is itself recursive, the cost is effectively linear in field count for typical balanced forms (shallow and wide) and degrades toward `O(N²)` for deeply nested trees. Call this method from submit or blur handlers rather than from tight reactive loops on large forms.

#### Returns

- `result` `RequiredPath[]`

#### Related

##### Methods

[`getDirtyInput`](/methods/api/getDirtyInput.md), [`getInput`](/methods/api/getInput.md), [`pickDirty`](/methods/api/pickDirty.md)

### getErrors

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.

```ts
const errors = getErrors<TSchema>(form);
const errors = getErrors<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath | undefined = undefined`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `GetFormErrorsConfig | GetFieldErrorsConfig<TSchema, TFieldPath> | undefined`

##### Explanation

The `form` parameter is the form store to retrieve errors from. The optional `config` parameter specifies which errors to retrieve - either form-level errors (when omitted) or field-specific errors (when a `path` is provided).

#### Returns

- `result` `[string, ...string[]] | null`

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`getDeepErrors`](/methods/api/getDeepErrors.md), [`setErrors`](/methods/api/setErrors.md), [`validate`](/methods/api/validate.md)

### getInput

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.

```ts
const input = getInput<TSchema>(form);
const input = getInput<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath | undefined = undefined`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `GetFormInputConfig | GetFieldInputConfig<TSchema, RequiredPath> | undefined`

##### Explanation

The `form` parameter is the form store to retrieve input from. The optional `config` parameter specifies which field to get input from - if omitted, returns input from the entire form.

#### Returns

- `result` `PartialValues<v.InferInput<TSchema>>`

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`setInput`](/methods/api/setInput.md), [`reset`](/methods/api/reset.md)

### handleSubmit

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.

```ts
const result = handleSubmit<TSchema>(form, handler);
```

> In React Native, where there is no form element or submit event, `handleSubmit` returns a plain async function that you call from a button's `onPress` or a text input's `onSubmitEditing` handler. In this case the handler receives only the validated form output — there is no event object.

#### Generics

- `TSchema` `extends FormSchema`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `handler` `SubmitHandler<TSchema> | SubmitEventHandler<TSchema>`

##### Explanation

The `form` parameter is the form store to handle submission for. The `handler` parameter can be a `SubmitHandler` (no event) or, in the frameworks that submit through a form element, a `SubmitEventHandler` (with event) that gets called with the validated form output if validation succeeds. In React Native only `SubmitHandler` applies, as there is no submit event.

#### Returns

- `result` `(() => Promise<void>) | ((event: SubmitEvent) => Promise<void>)`

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`validate`](/methods/api/validate.md), [`focus`](/methods/api/focus.md), [`submit`](/methods/api/submit.md)

### insert

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.

```ts
insert<TSchema, TFieldArrayPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldArrayPath` `extends RequiredPath`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `InsertConfig<TSchema, TFieldArrayPath>`

##### Explanation

The `form` parameter is the form store containing the field array. The `config` parameter specifies the path to the field array, the index where to insert the new item, and optional initial input values for the new item.

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md), [`useFieldArray`](/react/api/useFieldArray.md)

##### Methods

[`move`](/methods/api/move.md), [`remove`](/methods/api/remove.md), [`replace`](/methods/api/replace.md), [`swap`](/methods/api/swap.md)

### isDirty

Checks whether a specific field or the entire form is dirty by walking through the field store and all its descendants. A field is dirty when its input differs from its initial value.

```ts
const dirty = isDirty<TSchema>(form);
const dirty = isDirty<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath | undefined = undefined`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `IsFormDirtyConfig | IsFieldDirtyConfig<TSchema, TFieldPath> | undefined`

##### Explanation

The `form` parameter is the form store to check for dirtiness. The optional `config` parameter scopes the check to a specific field's subtree via a `path` (when omitted, the entire form is checked). The function walks through the field store and all its descendants and returns `true` as soon as it finds a dirty field.

#### Returns

- `result` `boolean`

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`getDirtyInput`](/methods/api/getDirtyInput.md), [`getDirtyPaths`](/methods/api/getDirtyPaths.md), [`pickDirty`](/methods/api/pickDirty.md), [`isTouched`](/methods/api/isTouched.md), [`isEdited`](/methods/api/isEdited.md), [`isValid`](/methods/api/isValid.md)

### isEdited

Checks whether a specific field or the entire form is edited by walking through the field store and all its descendants. A field is edited once its value has been changed by the user.

```ts
const edited = isEdited<TSchema>(form);
const edited = isEdited<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath | undefined = undefined`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `IsFormEditedConfig | IsFieldEditedConfig<TSchema, TFieldPath> | undefined`

##### Explanation

The `form` parameter is the form store to check for being edited. The optional `config` parameter scopes the check to a specific field's subtree via a `path` (when omitted, the entire form is checked). The function walks through the field store and all its descendants and returns `true` as soon as it finds an edited field.

#### Returns

- `result` `boolean`

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`isDirty`](/methods/api/isDirty.md), [`isTouched`](/methods/api/isTouched.md), [`isValid`](/methods/api/isValid.md)

### isTouched

Checks whether a specific field or the entire form is touched by walking through the field store and all its descendants. A field is touched once it has received and lost focus.

```ts
const touched = isTouched<TSchema>(form);
const touched = isTouched<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath | undefined = undefined`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `IsFormTouchedConfig | IsFieldTouchedConfig<TSchema, TFieldPath> | undefined`

##### Explanation

The `form` parameter is the form store to check for being touched. The optional `config` parameter scopes the check to a specific field's subtree via a `path` (when omitted, the entire form is checked). The function walks through the field store and all its descendants and returns `true` as soon as it finds a touched field.

#### Returns

- `result` `boolean`

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`isDirty`](/methods/api/isDirty.md), [`isEdited`](/methods/api/isEdited.md), [`isValid`](/methods/api/isValid.md), [`focus`](/methods/api/focus.md)

### isValid

Checks whether a specific field or the entire form is valid by walking through the field store and all its descendants. A field is valid when neither it nor any of its descendants contains an error.

```ts
const valid = isValid<TSchema>(form);
const valid = isValid<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath | undefined = undefined`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `IsFormValidConfig | IsFieldValidConfig<TSchema, TFieldPath> | undefined`

##### Explanation

The `form` parameter is the form store to check for validity. The optional `config` parameter scopes the check to a specific field's subtree via a `path` (when omitted, the entire form is checked). The function walks through the field store and all its descendants and returns `false` as soon as it finds an error.

#### Returns

- `result` `boolean`

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`getErrors`](/methods/api/getErrors.md), [`getDeepErrors`](/methods/api/getDeepErrors.md), [`isDirty`](/methods/api/isDirty.md), [`isTouched`](/methods/api/isTouched.md), [`isEdited`](/methods/api/isEdited.md)

### move

Moves an item within a field array from one index to another. All items between the old and new positions are shifted accordingly.

```ts
move<TSchema, TFieldArrayPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldArrayPath` `extends RequiredPath`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `MoveConfig<TSchema, TFieldArrayPath>`

##### Explanation

The `form` parameter is the form store containing the field array. The `config` parameter specifies the path to the field array and the indices to move the item from and to.

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md), [`useFieldArray`](/react/api/useFieldArray.md)

##### Methods

[`insert`](/methods/api/insert.md), [`remove`](/methods/api/remove.md), [`replace`](/methods/api/replace.md), [`swap`](/methods/api/swap.md)

### pickDirty

Picks only the dirty parts of the given value, using the form's dirty tree as a structural mask. Object keys whose subtree contains no dirty descendant are omitted; arrays are treated as atomic and returned in full whenever any descendant is dirty. Returns `undefined` if no field is dirty. Where the supplied value's shape diverges from the form's input shape — for example, a field expected to be an object holds a primitive, `null` or array — that branch is returned as-is. Useful for filtering a validated output to just the changed parts before submitting.

```ts
const dirty = pickDirty<TSchema, TValue>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TValue` `extends object`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `PickDirtyConfig<TValue>`

##### Explanation

The `form` parameter is the form store providing the dirty mask. The `config` parameter must include a `from` value to filter. The value's shape is expected to match the form's input shape — wherever the shapes diverge (e.g. an object key in the form holds a primitive, `null` or array in the supplied value), that branch is returned as-is so the divergence is preserved in the result. Use this when a Valibot schema transformation produces a value of a different shape than the form's input and you want to ship only the dirty parts of that output.

Internally, the function walks the form's field tree alongside the supplied value, using `getFieldBool` to skip clean subtrees and a constant-time check at each node to verify shape alignment. Because the dirty check is itself recursive, the cost is effectively linear in field count for typical balanced forms (shallow and wide) and degrades toward `O(N²)` for deeply nested trees. Call this method from submit or blur handlers rather than from tight reactive loops on large forms.

#### Returns

- `result` `DeepPartial<TValue> | undefined`

#### Related

##### Methods

[`getDirtyInput`](/methods/api/getDirtyInput.md), [`getDirtyPaths`](/methods/api/getDirtyPaths.md), [`getInput`](/methods/api/getInput.md)

### remove

Removes an item from a field array at the specified index. All items after the removed index are shifted down by one.

```ts
remove<TSchema, TFieldArrayPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldArrayPath` `extends RequiredPath`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `RemoveConfig<TSchema, TFieldArrayPath>`

##### Explanation

The `form` parameter is the form store containing the field array. The `config` parameter specifies the path to the field array and the index of the item to remove.

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md), [`useFieldArray`](/react/api/useFieldArray.md)

##### Methods

[`insert`](/methods/api/insert.md), [`move`](/methods/api/move.md), [`replace`](/methods/api/replace.md), [`swap`](/methods/api/swap.md)

### replace

Replaces an item in a field array at the specified index with a new item.

```ts
replace<TSchema, TFieldArrayPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldArrayPath` `extends RequiredPath`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `ReplaceConfig<TSchema, TFieldArrayPath>`

##### Explanation

The `form` parameter is the form store containing the field array. The `config` parameter specifies the path to the field array, the index of the item to replace, and the new item values.

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md), [`useFieldArray`](/react/api/useFieldArray.md)

##### Methods

[`insert`](/methods/api/insert.md), [`move`](/methods/api/move.md), [`remove`](/methods/api/remove.md), [`swap`](/methods/api/swap.md)

### reset

Resets the form or a specific field to its initial state or to a new initial input. Optionally keeps certain states like input values, touched state, or errors.

```ts
reset(form);
reset<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath | undefined = undefined`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `ResetFormConfig<TSchema> | ResetFieldConfig<TSchema, RequiredPath> | undefined`

##### Explanation

When called without a config or with `path` set to `undefined`, the entire form is reset. When a `path` is provided, only that specific field and its nested fields are reset.

By default, the form resets to its original initial input. However, you can pass a new `initialInput` in the config to update the form's baseline data. This is useful when remote data has changed and the form needs to reflect the updated values. Combined with `keepInput`, `keepTouched`, `keepEdited`, `keepErrors`, and `keepSubmitted`, you can update the initial state without overwriting the user's current edits.

###### More context on dirty tracking

Formisch distinguishes between two concepts:

- **Initial input**: the baseline value used for dirty tracking (often the server state).
- **Current input**: the value the user is currently editing (the client state).

Calling `reset` updates the initial input (baseline). Depending on the `keep*` options, it can also overwrite the current input, or keep it and just recompute state like `isDirty` based on the new baseline.

> If the initial input is `null` or `undefined`, Formisch does not treat an empty string or `NaN` as dirty. This helps when HTML inputs produce `''` or `NaN` for "empty" values.

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`setInput`](/methods/api/setInput.md), [`getInput`](/methods/api/getInput.md), [`setErrors`](/methods/api/setErrors.md), [`validate`](/methods/api/validate.md)

### setErrors

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.

```ts
setErrors<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath | undefined = undefined`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `SetFormErrorsConfig | SetFieldErrorsConfig<TSchema, TFieldPath>`

##### Explanation

The `form` parameter is the form store to set errors on. The `config` parameter specifies the path and error messages to set, or can be set to null to clear existing errors.

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`getErrors`](/methods/api/getErrors.md), [`getDeepErrors`](/methods/api/getDeepErrors.md), [`validate`](/methods/api/validate.md)

### setInput

Sets input values for the form or a specific field programmatically.

```ts
setInput<TSchema>(form, config);
setInput<TSchema, TFieldPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath | undefined = undefined`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `SetFormInputConfig<TSchema> | SetFieldInputConfig<TSchema, RequiredPath>`

##### Explanation

The `form` parameter is the form store to set input on. The `config` parameter specifies the path to the field and the new input values to set.

> `setInput` updates the **current input** (what the user is editing), but it does not change the **initial input** (the baseline used for `isDirty`). If your baseline data changes (e.g. after refetching from the server), prefer [`reset`](/methods/api/reset.md) with a new `initialInput`.

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`getInput`](/methods/api/getInput.md), [`reset`](/methods/api/reset.md)

### swap

Swaps two items in a field array at the specified indices.

```ts
swap<TSchema, TFieldArrayPath>(form, config);
```

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldArrayPath` `extends RequiredPath`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `SwapConfig<TSchema, TFieldArrayPath>`

##### Explanation

The `form` parameter is the form store containing the field array. The `config` parameter specifies the path to the field array and the two indices of the items to swap.

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md), [`useFieldArray`](/react/api/useFieldArray.md)

##### Methods

[`insert`](/methods/api/insert.md), [`move`](/methods/api/move.md), [`remove`](/methods/api/remove.md), [`replace`](/methods/api/replace.md)

### validate

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.

```ts
const result = validate<TSchema>(form, config?);
```

#### Generics

- `TSchema` `extends FormSchema`

#### Parameters

- `form` `BaseFormStore<TSchema>`
- `config` `ValidateFormConfig | undefined`

##### Explanation

The `form` parameter is the form store to validate. The optional `config` parameter allows specifying whether to automatically focus the first field with validation errors after validation.

#### Returns

- `result` `Promise<SafeParseResult<TSchema>>`

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`focus`](/methods/api/focus.md), [`handleSubmit`](/methods/api/handleSubmit.md), [`setErrors`](/methods/api/setErrors.md), [`getErrors`](/methods/api/getErrors.md), [`getDeepErrors`](/methods/api/getDeepErrors.md)

## Types

### DeepErrorEntry

Entry that pairs the `path` to a field with its error messages. Returned by the `getDeepErrorEntries` method. Form-level errors are included with an empty path.

#### Generics

- `TValue` `extends unknown`

#### Definition

- `DeepErrorEntry`
  - `path` `unknown extends TValue ? Path : readonly [] | FieldPath<TValue>`
  - `errors` `[string, ...string[]]`

#### Related

##### Methods

[`getDeepErrorEntries`](/methods/api/getDeepErrorEntries.md)

### DeepPartial

A utility type that recursively makes all properties and nested properties optional.

> This type is too complex to display. Please refer to the [source code](https://github.com/open-circle/formisch/blob/main/packages/core/src/types/utils/utils.ts).

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

### EmptyInput

Empty input interface that defines the value a required field of a given type starts at when no initial input is provided. Optional and nullable fields are not affected, as they accept `undefined`.

#### Definition

- `EmptyInput`
  - `string` `string | undefined`
  - `number` `number | undefined`
  - `boolean` `boolean | undefined`
  - `date` `Date | undefined`

##### Explanation

Only required fields whose input is `undefined` fall back to these values. The `string` property defaults to an empty string so that an untouched field matches the DOM and validates with its own message instead of a type mismatch. The other properties default to `undefined`.

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Types

[`FormConfig`](/react/api/FormConfig.md)

### FieldArrayStore

Reactive field array store interface with properties for managing array fields.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldArrayPath` `extends RequiredPath`

#### Definition

- `FieldArrayStore`
  - `path` `ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>`
  - `items` `string[]`
  - `errors` `[string, ...string[]] | null`
  - `isTouched` `boolean`
  - `isEdited` `boolean`
  - `isDirty` `boolean`
  - `isValid` `boolean`

### FieldElement

The imperative methods of the native components that can be registered with a field store.

#### Definition

- `FieldElement`
  - `focus` `() => void`
  - `blur` `(() => void) | undefined`
  - `isFocused` `(() => boolean) | undefined`

##### Explanation

React Native has no DOM elements. Instead of a union of HTML elements, `FieldElement` is a structural subset of the imperative methods that React Native host component instances provide. This way the refs of `TextInput` and other focusable native components are accepted without depending on the `react-native` package.

Only `focus` is required, as it is what [`focus`](/methods/api/focus.md) calls to focus a field. `isFocused` is implemented by `TextInput` and is used to verify that an element actually received focus, so that elements which cannot be focused are skipped.

#### Related

##### Methods

[`focus`](/methods/api/focus.md)

##### Types

[`FieldElementProps`](/react-native/api/FieldElementProps.md)

### FieldElementProps

Props to spread onto a field element for integration with React Native form handling.

#### Definition

- `FieldElementProps`
  - `ref` `((element: FieldElement | null) => void | (() => void))`
  - `onFocus` `() => void`
  - `onBlur` `() => void`
  - `onChangeText` `(text: string) => void`

##### Explanation

The props are spread onto a `TextInput` to connect it to the form. Since React Native has no native form elements, inputs are controlled. Therefore, always pass `value={field.input}` alongside the spread props. The `onChangeText` handler updates the field input whenever the text changes.

Non-text components such as `Switch`, sliders and pickers do not report text, so spreading these props is not enough to connect them: pass their value from `field.input` and their change handler to the field store's `onChange` method instead. The `ref` and the `onFocus` and `onBlur` handlers can still be forwarded to make such a component focusable and to keep its touched and blurred state.

The `ref` callback registers the native component instance. [`FieldElement`](/react-native/api/FieldElement.md) is a structural subset of the imperative methods of React Native host component instances, so refs of `TextInput` and other focusable native components are accepted. On React 19 the callback returns a cleanup function that unregisters the exact element, while React 18 calls the callback with `null` instead.

### FieldStore

Reactive field store interface with properties and element props for field management.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `FieldStore`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`
  - `input` `PartialValues<PathValue<v.InferInput<TSchema>, TFieldPath>>`
  - `errors` `[string, ...string[]] | null`
  - `isTouched` `boolean`
  - `isEdited` `boolean`
  - `isDirty` `boolean`
  - `isValid` `boolean`
  - `onChange` `(value: PartialValues<PathValue<v.InferInput<TSchema>, TFieldPath>>) => void`
  - `props` `FieldElementProps`

### FocusFieldConfig

Configuration interface for focusing a field. Used by the `focus` method to specify which field to focus and any additional focus options.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `FocusFieldConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`

#### Related

##### Methods

[`focus`](/methods/api/focus.md)

### FormConfig

Form config interface that defines the configuration options for creating a form store with [`useForm`](/react-native/api/useForm.md).

#### Generics

- `TSchema` `extends FormSchema`

#### Definition

- `FormConfig`
  - `schema` `TSchema`
  - `initialInput` `DeepPartial<v.InferInput<TSchema>> | undefined`
  - `emptyInput` `EmptyInput | undefined`
  - `validate` `ValidationMode | undefined`
  - `revalidate` `Exclude<ValidationMode, 'initial'> | undefined`

##### Explanation

The `FormConfig` object is passed to [`useForm`](/react-native/api/useForm.md) with a required `schema` property and optional properties for `initialInput`, `emptyInput`, `validate`, and `revalidate` to control form behavior and validation timing.

### FormSchema

Type definition that represents the Valibot schemas allowed as the root of a form. Forms must have an object root, so this is constrained structurally to any schema with an object output rather than to specific schema types. This includes object schemas, combinators (`intersect`, `union`, `variant`) over objects, `lazy` schemas wrapping any of these, and generic object schemas like `v.GenericSchema<{ … }>`. Use [Schema](/core/api/Schema.md) for nested field schemas.

#### Definition

- `FormSchema` `GenericSchema<Record<string, unknown>> | GenericSchemaAsync<Record<string, unknown>>`

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`validate`](/methods/api/validate.md)

### FormStore

Form store interface that provides reactive access to the state of a form created with [`useForm`](/react-native/api/useForm.md).

#### Generics

- `TSchema` `extends FormSchema`

#### Definition

- `FormStore`
  - `isSubmitting` `boolean`
  - `isSubmitted` `boolean`
  - `isValidating` `boolean`
  - `isTouched` `boolean`
  - `isEdited` `boolean`
  - `isDirty` `boolean`
  - `isValid` `boolean`
  - `errors` `[string, ... string[]] | null`

##### Explanation

The `errors` property only contains validation errors at the root level of the form. These are errors from the root object schema validation itself, not errors from nested fields. To retrieve all validation errors from all fields across the entire form, use the [`getDeepErrors`](/methods/api/getDeepErrors.md) method instead.

### GetFieldDeepErrorEntriesConfig

Configuration interface for retrieving the error entries of a specific field. Used by the `getDeepErrorEntries` method when a specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `GetFieldDeepErrorEntriesConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`

#### Related

##### Methods

[`getDeepErrorEntries`](/methods/api/getDeepErrorEntries.md)

### GetFieldDeepErrorsConfig

Configuration interface for retrieving the errors of a specific field. Used by the `getDeepErrors` method when a specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `GetFieldDeepErrorsConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`

#### Related

##### Methods

[`getDeepErrors`](/methods/api/getDeepErrors.md)

### GetFieldDirtyInputConfig

Configuration interface for retrieving field-scoped dirty input. Used by the `getDirtyInput` method when a specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `GetFieldDirtyInputConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`

#### Related

##### Methods

[`getDirtyInput`](/methods/api/getDirtyInput.md)

### GetFieldDirtyPathsConfig

Configuration interface for inspecting field-scoped dirty paths. Used by the `getDirtyPaths` method when a specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `GetFieldDirtyPathsConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`

#### Related

##### Methods

[`getDirtyPaths`](/methods/api/getDirtyPaths.md)

### GetFieldErrorsConfig

Configuration interface for retrieving field-specific errors. Used by the `getErrors` method when a specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `GetFieldErrorsConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`

#### Related

##### Methods

[`getErrors`](/methods/api/getErrors.md)

### GetFieldInputConfig

Configuration interface for retrieving field-specific input. Used by the `getInput` method when a specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `GetFieldInputConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`

#### Related

##### Methods

[`getInput`](/methods/api/getInput.md)

### GetFormDeepErrorEntriesConfig

Configuration interface for retrieving the error entries of the entire form. Used by the `getDeepErrorEntries` method when no specific field path is provided.

#### Definition

- `GetFormDeepErrorEntriesConfig`
  - `path` `undefined = undefined`

#### Related

##### Methods

[`getDeepErrorEntries`](/methods/api/getDeepErrorEntries.md)

### GetFormDeepErrorsConfig

Configuration interface for retrieving the errors of the entire form. Used by the `getDeepErrors` method when no specific field path is provided.

#### Definition

- `GetFormDeepErrorsConfig`
  - `path` `undefined = undefined`

#### Related

##### Methods

[`getDeepErrors`](/methods/api/getDeepErrors.md)

### GetFormDirtyInputConfig

Configuration interface for retrieving form-level dirty input. Used by the `getDirtyInput` method when no specific field path is provided.

#### Definition

- `GetFormDirtyInputConfig`
  - `path` `undefined = undefined`

#### Related

##### Methods

[`getDirtyInput`](/methods/api/getDirtyInput.md)

### GetFormDirtyPathsConfig

Configuration interface for inspecting form-level dirty paths. Used by the `getDirtyPaths` method when no specific field path is provided.

#### Definition

- `GetFormDirtyPathsConfig`
  - `path` `undefined = undefined`

#### Related

##### Methods

[`getDirtyPaths`](/methods/api/getDirtyPaths.md)

### GetFormErrorsConfig

Configuration interface for retrieving form-level errors. Used by the `getErrors` method when no specific field path is provided.

#### Definition

- `GetFormErrorsConfig`
  - `path` `undefined = undefined`

#### Related

##### Methods

[`getErrors`](/methods/api/getErrors.md)

### GetFormInputConfig

Configuration interface for retrieving form-level input. Used by the `getInput` method when no specific field path is provided.

#### Definition

- `GetFormInputConfig`
  - `path` `undefined = undefined`

#### Related

##### Methods

[`getInput`](/methods/api/getInput.md)

### InsertConfig

Configuration interface for inserting items into array fields. Used by the `insert` method.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldArrayPath` `extends RequiredPath`

#### Definition

- `InsertConfig`
  - `path` `ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>`
  - `at` `number | undefined`
  - `initialInput` `DeepPartial<PathValue<v.InferInput<TSchema>, [...TFieldArrayPath, number]>> | undefined`

#### Related

##### Methods

[`insert`](/methods/api/insert.md)

### IsFieldDirtyConfig

Configuration interface for checking whether a specific field is dirty. Used by the `isDirty` method when a specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `IsFieldDirtyConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`

#### Related

##### Methods

[`isDirty`](/methods/api/isDirty.md)

### IsFieldEditedConfig

Configuration interface for checking whether a specific field is edited. Used by the `isEdited` method when a specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `IsFieldEditedConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`

#### Related

##### Methods

[`isEdited`](/methods/api/isEdited.md)

### IsFieldTouchedConfig

Configuration interface for checking whether a specific field is touched. Used by the `isTouched` method when a specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `IsFieldTouchedConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`

#### Related

##### Methods

[`isTouched`](/methods/api/isTouched.md)

### IsFieldValidConfig

Configuration interface for checking whether a specific field is valid. Used by the `isValid` method when a specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `IsFieldValidConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`

#### Related

##### Methods

[`isValid`](/methods/api/isValid.md)

### IsFormDirtyConfig

Configuration interface for checking whether the entire form is dirty. Used by the `isDirty` method when no specific field path is provided.

#### Definition

- `IsFormDirtyConfig`
  - `path` `undefined = undefined`

#### Related

##### Methods

[`isDirty`](/methods/api/isDirty.md)

### IsFormEditedConfig

Configuration interface for checking whether the entire form is edited. Used by the `isEdited` method when no specific field path is provided.

#### Definition

- `IsFormEditedConfig`
  - `path` `undefined = undefined`

#### Related

##### Methods

[`isEdited`](/methods/api/isEdited.md)

### IsFormTouchedConfig

Configuration interface for checking whether the entire form is touched. Used by the `isTouched` method when no specific field path is provided.

#### Definition

- `IsFormTouchedConfig`
  - `path` `undefined = undefined`

#### Related

##### Methods

[`isTouched`](/methods/api/isTouched.md)

### IsFormValidConfig

Configuration interface for checking whether the entire form is valid. Used by the `isValid` method when no specific field path is provided.

#### Definition

- `IsFormValidConfig`
  - `path` `undefined = undefined`

#### Related

##### Methods

[`isValid`](/methods/api/isValid.md)

### PartialValues

Utility type that recursively makes all value properties optional, including nested objects and arrays.

#### Generics

- `TValue` `unknown`

#### Definition

- `PartialValues` `TValue | undefined`

#### Related

##### Methods

[`getInput`](/methods/api/getInput.md)

### Path

Type definition for readonly arrays of path keys used to access nested properties.

#### Definition

- `Path` `ReadonlyArray<PathKey>`

### PathKey

Type definition for keys used in paths to access nested properties in objects and arrays.

#### Definition

- `PathKey` `string | number`

### PickDirtyConfig

Configuration interface for picking dirty parts of a value. Used by the `pickDirty` method.

#### Generics

- `TValue` `extends object`

#### Definition

- `PickDirtyConfig`
  - `from` `TValue`

#### Related

##### Methods

[`pickDirty`](/methods/api/pickDirty.md)

### MoveConfig

Configuration interface for moving items within array fields. Used by the `move` method.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldArrayPath` `extends RequiredPath`

#### Definition

- `MoveConfig`
  - `path` `ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>`
  - `from` `number`
  - `to` `number`

#### Related

##### Methods

[`move`](/methods/api/move.md)

### RemoveConfig

Configuration interface for removing items from array fields. Used by the `remove` method.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldArrayPath` `extends RequiredPath`

#### Definition

- `RemoveConfig`
  - `path` `ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>`
  - `at` `number`

#### Related

##### Methods

[`remove`](/methods/api/remove.md)

### ReplaceConfig

Configuration interface for replacing items in array fields. Used by the `replace` method.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldArrayPath` `extends RequiredPath`

#### Definition

- `ReplaceConfig`
  - `path` `ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>`
  - `at` `number`
  - `initialInput` `DeepPartial<PathValue<v.InferInput<TSchema>, [...TFieldArrayPath, number]>> | undefined`

#### Related

##### Methods

[`replace`](/methods/api/replace.md)

### RequiredPath

A type that represents a required path into an object structure with at least one key.

> This type is too complex to display. Please refer to the [source code](https://github.com/open-circle/formisch/blob/main/packages/core/src/types/path/path.ts).

#### Related

##### Methods

[`focus`](/methods/api/focus.md), [`getErrors`](/methods/api/getErrors.md), [`getInput`](/methods/api/getInput.md), [`replace`](/methods/api/replace.md), [`setInput`](/methods/api/setInput.md), [`swap`](/methods/api/swap.md)

### ResetFieldConfig

Configuration interface for resetting field-specific input and errors. Used by the `reset` method when a specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `ResetFieldConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`
  - `initialInput` `DeepPartial<PathValue<v.InferInput<TSchema>, TFieldPath>> = undefined`
  - `keepEdited` `boolean = false`
  - `keepErrors` `boolean = false`
  - `keepInput` `boolean = false`
  - `keepTouched` `boolean = false`

#### Related

##### Methods

[`reset`](/methods/api/reset.md)

### ResetFormConfig

Configuration interface for resetting form input and errors. Used by the `reset` method when no specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`

#### Definition

- `ResetFormConfig`
  - `initialInput` `DeepPartial<v.InferInput<TSchema>> = undefined`
  - `keepEdited` `boolean = false`
  - `keepErrors` `boolean = false`
  - `keepInput` `boolean = false`
  - `keepSubmitted` `boolean = false`
  - `keepTouched` `boolean = false`

#### Related

##### Methods

[`reset`](/methods/api/reset.md)

### Schema

Schema type definition that represents any Valibot schema that can be used with Formisch.

#### Definition

- `Schema` `GenericSchema | GenericSchemaAsync`

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`validate`](/methods/api/validate.md)

### SetFieldErrorsConfig

Configuration interface for setting field-specific errors. Used by the `setErrors` method when a specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `SetFieldErrorsConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`
  - `errors` `[string, ...string[]] | null`

#### Related

##### Methods

[`setErrors`](/methods/api/setErrors.md)

### SetFieldInputConfig

Configuration interface for setting field-specific input. Used by the `setInput` method when a specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `SetFieldInputConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`
  - `input` `PathValue<v.InferInput<TSchema>, TFieldPath>`

#### Related

##### Methods

[`setInput`](/methods/api/setInput.md)

### SetFormErrorsConfig

Configuration interface for setting form-level errors. Used by the `setErrors` method when no specific field path is provided.

#### Definition

- `SetFormErrorsConfig`
  - `path` `undefined = undefined`
  - `errors` `[string, ...string[]] | null`

#### Related

##### Methods

[`setErrors`](/methods/api/setErrors.md)

### SetFormInputConfig

Configuration interface for setting form-level input. Used by the `setInput` method when no specific field path is provided.

#### Generics

- `TSchema` `extends FormSchema`

#### Definition

- `SetFormInputConfig`
  - `path` `undefined = undefined`
  - `input` `v.InferInput<TSchema>`

#### Related

##### Methods

[`setInput`](/methods/api/setInput.md)

### SubmitHandler

Function type for handling form submission without the submit event. Used by the `handleSubmit` method.

#### Generics

- `TSchema` `extends FormSchema`

#### Parameters

- `output` `InferOutput<TSchema>`

#### Related

##### Methods

[`handleSubmit`](/methods/api/handleSubmit.md)

##### Types

[`SubmitEventHandler`](/core/api/SubmitEventHandler.md)

### SwapConfig

Configuration interface for swapping items in array fields. Used by the `swap` method.

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldArrayPath` `extends RequiredPath`

#### Definition

- `SwapConfig`
  - `path` `ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>`
  - `at` `number`
  - `and` `number`

#### Related

##### Methods

[`swap`](/methods/api/swap.md)

### UseFieldArrayConfig

Configuration object for creating a field array store with [`useFieldArray`](/react-native/api/useFieldArray.md).

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldArrayPath` `extends RequiredPath`

#### Definition

- `UseFieldArrayConfig`
  - `path` `ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>`

### UseFieldConfig

Configuration object for creating a field store with [`useField`](/react-native/api/useField.md).

#### Generics

- `TSchema` `extends FormSchema`
- `TFieldPath` `extends RequiredPath`

#### Definition

- `UseFieldConfig`
  - `path` `ValidPath<v.InferInput<TSchema>, TFieldPath>`

### ValidArrayPath

A utility type that validates array paths and returns the first possible valid array path based on the given value if the provided path is invalid.

> This type is too complex to display. Please refer to the [source code](https://github.com/open-circle/formisch/blob/main/packages/core/src/types/path/path.ts).

### ValidateFormConfig

Configuration interface for form validation. Used by the `validate` method to specify validation behavior.

#### Definition

- `ValidateFormConfig`
  - `shouldFocus` `boolean = false`

#### Related

##### Methods

[`validate`](/methods/api/validate.md)

### ValidationMode

Validation mode type that defines when and how form validation is triggered.

#### Definition

- `ValidationMode` `'initial' | 'touch' | 'input' | 'change' | 'blur' | 'submit'`

#### Related

##### Primitives

[`useForm`](/react/api/useForm.md)

##### Methods

[`validate`](/methods/api/validate.md)