@formisch/vue 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -1,55 +1,185 @@
 import * as v from "valibot";
-import * as vue11 from "vue";
+import * as vue3 from "vue";
 import { ComponentPublicInstance, MaybeRefOrGetter, ShallowRef as Signal } from "vue";
 
 //#region ../../packages/core/dist/index.vue.d.ts
+
 //#region src/types/schema.d.ts
+/**
+* Schema type.
+*/
 type Schema = v.GenericSchema | v.GenericSchemaAsync;
 //#endregion
 //#region src/types/signal.d.ts
+/**
+* Batch interface.
+*/
 
 //#endregion
 //#region src/types/field.d.ts
 /**
-* Value type of the field element.
+* 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
@@ -76,28 +206,81 @@ type PartialValues<TValue> = TValue extends readonly unknown[] ? number extends
 //#endregion
 //#region src/types/form.d.ts
 /**
-* Value type of the validation mode.
+* 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> {
-  [INTERNAL]: InternalFormStore<TSchema>;
+  /**
+  * 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
@@ -126,7 +309,7 @@ type KeyOf<TValue> = IsAny<TValue> extends true ? never : TValue extends readonl
 */
 type MergeUnion<T> = { [K in KeyOf<T>]: T extends Record<K, infer V> ? V : never };
 /**
-* Lazily evaluate only the first valid path segment based on the given value.
+* 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;
 /**
@@ -147,272 +330,733 @@ type IsOrHasArray<TValue> = IsAny<TValue> extends true ? false : TValue extends
 */
 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 evaluate only the first valid array path segment based on the given value.
+* 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.
+* 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 array item to another.
-* This includes the `isTouched`, `isDirty`, `startInput`, `input`, `startItems`, and `items` properties.
+* 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 internalArrayStore - The field store of the array (not the array item)
-* @param fromIndex - The source index to copy from
-* @param toIndex - The destination index to copy to
+* @param fromInternalFieldStore The source field store to copy from.
+* @param toInternalFieldStore The destination field store to copy to.
 */
 //#endregion
 //#region ../../packages/methods/dist/index.vue.d.ts
 //#region src/focus/focus.d.ts
+
+/**
+* Focus field config interface.
+*/
 interface FocusFieldConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
-  readonly form: BaseFormStore<TSchema>;
+  /**
+  * The path to the field to focus.
+  */
   readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
 }
-declare function focus<TSchema extends Schema, TFieldPath extends RequiredPath>(config: FocusFieldConfig<TSchema, TFieldPath>): void;
+/**
+* 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) => 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;
-  readonly keepSubmitCount?: boolean | 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
 /**
- * Value type of the field element props.
+ * Field element props interface.
  */
 interface FieldElementProps {
+  /**
+   * The name of the field.
+   */
   readonly name: string;
+  /**
+   * Whether the field should autofocus.
+   */
   readonly autofocus: boolean;
+  /**
+   * The ref callback to register the field element.
+   */
   readonly ref: (element: Element | ComponentPublicInstance | null) => void;
+  /**
+   * The focus event handler of the field element.
+   */
   readonly onFocus: (event: FocusEvent) => void;
+  /**
+   * The change event handler of the field element.
+   */
   readonly onChange: (event: Event) => void;
+  /**
+   * The blur event handler of the field element.
+   */
   readonly onBlur: (event: FocusEvent) => void;
 }
 /**
- * Value type of the field store.
+ * 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.
+   */
   get input(): PartialValues<PathValue<v.InferInput<TSchema>, TFieldPath>>;
+  /**
+   * Sets the current input value of the field.
+   */
   set input(value: 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 for the field element.
+   */
   readonly props: FieldElementProps;
 }
 /**
- * Value type of the field array store.
+ * 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.vue.d.ts
 /**
- * Properties of the `Field` component.
+ * 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>;
 }
-declare const _default: <TSchema extends Schema, TFieldPath extends RequiredPath>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$2<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-  props: __VLS_PrettifyLocal$2<Pick<Partial<{}> & Omit<{} & vue11.VNodeProps & vue11.AllowedComponentProps & vue11.ComponentCustomProps, never>, never> & FieldProps<TSchema, TFieldPath> & {}> & vue11.PublicProps;
-  expose(exposed: vue11.ShallowUnwrapRef<{}>): void;
+declare const __VLS_export$2: <TSchema extends Schema, TFieldPath extends RequiredPath>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$2<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$2<FieldProps<TSchema, TFieldPath>> & vue3.PublicProps;
+  expose: (exposed: {}) => void;
   attrs: any;
   slots: {
     default(props: FieldStore<TSchema, TFieldPath>): any;
   };
   emit: {};
-}>) => vue11.VNode & {
+}>) => vue3.VNode & {
   __ctx?: Awaited<typeof __VLS_setup>;
 };
+declare const _default: typeof __VLS_export$2;
 type __VLS_PrettifyLocal$2<T> = { [K in keyof T as K]: T[K] } & {};
 //#endregion
 //#region src/components/FieldArray/FieldArray.vue.d.ts
 /**
- * Properties of the `FieldArray` component.
+ * Field array 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>;
 }
-declare const _default$1: <TSchema extends Schema, TFieldArrayPath extends RequiredPath>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$1<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-  props: __VLS_PrettifyLocal$1<Pick<Partial<{}> & Omit<{} & vue11.VNodeProps & vue11.AllowedComponentProps & vue11.ComponentCustomProps, never>, never> & FieldArrayProps<TSchema, TFieldArrayPath> & {}> & vue11.PublicProps;
-  expose(exposed: vue11.ShallowUnwrapRef<{}>): void;
+declare const __VLS_export$1: <TSchema extends Schema, TFieldArrayPath extends RequiredPath>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$1<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$1<FieldArrayProps<TSchema, TFieldArrayPath>> & vue3.PublicProps;
+  expose: (exposed: {}) => void;
   attrs: any;
   slots: {
     default(props: FieldArrayStore<TSchema, TFieldArrayPath>): any;
   };
   emit: {};
-}>) => vue11.VNode & {
+}>) => vue3.VNode & {
   __ctx?: Awaited<typeof __VLS_setup>;
 };
+declare const _default$1: typeof __VLS_export$1;
 type __VLS_PrettifyLocal$1<T> = { [K in keyof T as K]: T[K] } & {};
 //#endregion
 //#region src/components/Form/Form.vue.d.ts
+/**
+ * Form component props interface.
+ */
 interface FormProps<TSchema extends Schema = Schema> {
+  /**
+   * The form store instance.
+   */
   of: FormStore<TSchema>;
+  /**
+   * The submit handler called when the form is submitted and validation succeeds.
+   */
   onSubmit: SubmitHandler<TSchema>;
 }
-declare const _default$2: <TSchema extends Schema = Schema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-  props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & vue11.VNodeProps & vue11.AllowedComponentProps & vue11.ComponentCustomProps, never>, never> & FormProps<TSchema> & {}> & vue11.PublicProps;
-  expose(exposed: vue11.ShallowUnwrapRef<{}>): void;
+declare const __VLS_export: <TSchema extends Schema = Schema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal<FormProps<TSchema>> & vue3.PublicProps;
+  expose: (exposed: {}) => void;
   attrs: any;
   slots: {
     default?: (props: {}) => any;
   };
   emit: {};
-}>) => vue11.VNode & {
+}>) => vue3.VNode & {
   __ctx?: Awaited<typeof __VLS_setup>;
 };
+declare const _default$2: typeof __VLS_export;
 type __VLS_PrettifyLocal<T> = { [K in keyof T as K]: T[K] } & {};
 //#endregion
 //#region src/composables/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, ref, or getter function.
+ * @param config The field configuration, ref, or getter function.
+ *
+ * @returns The field store with reactive properties and element props.
+ */
 declare function useField<TSchema extends Schema, TFieldPath extends RequiredPath>(form: MaybeRefOrGetter<FormStore<TSchema>>, config: MaybeRefOrGetter<UseFieldConfig<TSchema, TFieldPath>>): FieldStore<TSchema, TFieldPath>;
 //#endregion
 //#region src/composables/useFieldArray/useFieldArray.d.ts
+/**
+ * Use field array config interface.
+ */
 interface UseFieldArrayConfig<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
+  /**
+   * The path to the field array 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, ref, or getter function.
+ * @param config The field array configuration, ref, or getter function.
+ *
+ * @returns The field array store with reactive properties for array management.
+ */
 declare function useFieldArray<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: MaybeRefOrGetter<FormStore<TSchema>>, config: MaybeRefOrGetter<UseFieldArrayConfig<TSchema, TFieldArrayPath>>): FieldArrayStore<TSchema, TFieldArrayPath>;
 //#endregion
 //#region src/composables/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 { _default as Field, _default$1 as FieldArray, FieldArrayStore, FieldElementProps, FieldStore, FocusFieldConfig, _default$2 as Form, FormStore, GetFieldErrorsConfig, GetFieldInputConfig, GetFormErrorsConfig, GetFormInputConfig, InsertConfig, MoveConfig, RemoveConfig, ReplaceConfig, ResetFieldConfig, ResetFormConfig, SetFieldErrorsConfig, SetFieldInputConfig, SetFormErrorsConfig, SetFormInputConfig, type SubmitHandler, SwapConfig, UseFieldArrayConfig, UseFieldConfig, ValidateFormConfig, focus, getAllErrors, getErrors, getInput, handleSubmit, insert, move, remove, replace, reset, setErrors, setInput, submit, swap, useField, useFieldArray, useForm, validate };
+export { type DeepPartial, _default as Field, _default$1 as FieldArray, FieldArrayStore, type FieldElement, FieldElementProps, FieldStore, FocusFieldConfig, _default$2 as Form, type FormConfig, 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 };