@formisch/qwik 0.1.0 → 0.1.1

package/README.md

@@ -58,7 +58,7 @@ export default component$(() => {
 });
 ```
 
-In addition, Formisch offers several functions (we call them "methods") that can be used to manipulate the form state. These include `reset`, `setInput`, and `setErrors`. These methods allow you to control the form programmatically.
+In addition, Formisch offers several functions (we call them "methods") that can be used to read and manipulate the form state. These include `focus`, `getErrors`, `getAllErrors`, `getInput`, `insert`, `move`, `remove`, `replace`, `reset`, `setErrors`, `setInput`, `submit`, `swap` and `validate`. These methods allow you to control the form programmatically.
 
 ## Feedback
 

package/dist/index.d.ts

@@ -0,0 +1,392 @@
+import * as v from "valibot";
+import { JSXOutput, NoSerialize, PropsOf, QRL, ReadonlySignal } from "@qwik.dev/core";
+import * as _qwik_dev_core_internal3 from "@qwik.dev/core/internal";
+
+//#region ../../packages/core/dist/index.qwik.d.ts
+//#region src/types/schema.d.ts
+type Schema = v.GenericSchema | v.GenericSchemaAsync;
+//#endregion
+//#region src/types/signal.d.ts
+interface Signal<T> {
+  value: T;
+}
+//#endregion
+//#region src/types/field.d.ts
+/**
+* Value type of the field element.
+*/
+type FieldElement = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
+//#endregion
+//#region src/types/field.qwik.d.ts
+interface InternalBaseStore {
+  kind: "array" | "object" | "value";
+  name: string;
+  schema: NoSerialize<Schema>;
+  elements: FieldElement[];
+  errors: Signal<[string, ...string[]] | null>;
+}
+interface InternalArrayStore extends InternalBaseStore {
+  kind: "array";
+  children: InternalFieldStore[];
+  initialItems: Signal<string[]>;
+  startItems: Signal<string[]>;
+  items: Signal<string[]>;
+  isTouched: Signal<boolean>;
+  isDirty: Signal<boolean>;
+}
+interface InternalObjectStore extends InternalBaseStore {
+  kind: "object";
+  children: Record<string, InternalFieldStore>;
+}
+interface InternalValueStore extends InternalBaseStore {
+  kind: "value";
+  initialInput: Signal<unknown>;
+  startInput: Signal<unknown>;
+  input: Signal<unknown>;
+  isTouched: Signal<boolean>;
+  isDirty: Signal<boolean>;
+}
+type InternalFieldStore = InternalArrayStore | InternalObjectStore | InternalValueStore;
+//#endregion
+//#region src/values.d.ts
+declare const INTERNAL: "~internal";
+//#endregion
+//#region src/types/utils.d.ts
+/**
+* Checks if a type is `any`.
+*/
+type IsAny<Type> = 0 extends 1 & Type ? true : false;
+/**
+* Checks if a type is `never`.
+*/
+type IsNever<Type> = [Type] extends [never] ? true : false;
+/**
+* Constructs a type that is maybe a promise.
+*/
+type MaybePromise<TValue> = TValue | Promise<TValue>;
+/**
+* Makes all properties deeply optional.
+*/
+type DeepPartial<TValue> = TValue extends readonly unknown[] ? number extends TValue["length"] ? TValue : { [Key in keyof TValue]?: DeepPartial<TValue[Key]> | undefined } : TValue extends Record<PropertyKey, unknown> ? { [Key in keyof TValue]?: DeepPartial<TValue[Key]> | undefined } : TValue | undefined;
+/**
+* Makes all value properties optional.
+*/
+type PartialValues<TValue> = TValue extends readonly unknown[] ? number extends TValue["length"] ? TValue : { [Key in keyof TValue]: PartialValues<TValue[Key]> } : TValue extends Record<PropertyKey, unknown> ? { [Key in keyof TValue]: PartialValues<TValue[Key]> } : TValue | undefined;
+//#endregion
+//#region src/types/form.d.ts
+/**
+* Value type of the validation mode.
+*/
+type ValidationMode = "initial" | "touch" | "input" | "change" | "blur" | "submit";
+type SubmitHandler<TSchema extends Schema> = (output: v.InferOutput<TSchema>, event: SubmitEvent) => MaybePromise<void>;
+//#endregion
+//#region src/types/form.qwik.d.ts
+interface FormConfig<TSchema extends Schema = Schema> {
+  readonly schema: TSchema;
+  readonly initialInput?: DeepPartial<v.InferInput<TSchema>> | undefined;
+  readonly validateOn?: ValidationMode | undefined;
+  readonly revalidateOn?: Exclude<ValidationMode, "initial"> | undefined;
+}
+interface InternalFormStore<TSchema extends Schema = Schema> extends InternalObjectStore {
+  element?: HTMLFormElement;
+  validators: number;
+  validateOn: ValidationMode;
+  revalidateOn: Exclude<ValidationMode, "initial">;
+  validate: QRL<(input: unknown) => Promise<v.SafeParseResult<TSchema>>>;
+  isSubmitting: Signal<boolean>;
+  isSubmitted: Signal<boolean>;
+  isValidating: Signal<boolean>;
+}
+interface BaseFormStore<TSchema extends Schema = Schema> {
+  [INTERNAL]: InternalFormStore<TSchema>;
+}
+//#endregion
+//#region src/types/path.d.ts
+/**
+* Path key type.
+*/
+type PathKey = string | number;
+/**
+* Path type.
+*/
+type Path = readonly PathKey[];
+/**
+* Required path type.
+*/
+type RequiredPath = readonly [PathKey, ...Path];
+/**
+* Extracts the exact keys of a tuple, array or object.
+*/
+type KeyOf<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly unknown[] ? number extends TValue["length"] ? number : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? TIndex : never }[number] : TValue extends Record<string, unknown> ? keyof TValue & PathKey : never;
+/**
+* Merges array and object unions into a single object.
+*
+* Hint: This is necessary to make any property accessible. By default,
+* properties that do not exist in all union options are not accessible
+* and result in "any" when accessed.
+*/
+type MergeUnion<T> = { [K in KeyOf<T>]: T extends Record<K, infer V> ? V : never };
+/**
+* Lazily evaluate 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<MergeUnion<TValue>[TFirstKey], TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<KeyOf<TValue>> extends false ? readonly [...TValidPath, KeyOf<TValue>] : TValidPath;
+/**
+* Returns the path if valid, otherwise the first possible valid path based on
+* the given value.
+*/
+type ValidPath<TValue, TPath extends RequiredPath> = TPath extends LazyPath<TValue, TPath> ? TPath : LazyPath<TValue, TPath>;
+/**
+* Extracts the value type at the given path.
+*/
+type PathValue<TValue, TPath extends Path> = TPath extends readonly [infer TKey, ...infer TRest extends Path] ? TKey extends KeyOf<TValue> ? PathValue<MergeUnion<TValue>[TKey], TRest> : unknown : TValue;
+/**
+* Checks if a value is an array or contains one.
+*/
+type IsOrHasArray<TValue> = IsAny<TValue> extends true ? false : TValue extends readonly unknown[] ? true : TValue extends Record<string, unknown> ? true extends { [TKey in keyof TValue]: IsOrHasArray<TValue[TKey]> }[keyof TValue] ? true : false : false;
+/**
+* Extracts the exact keys of a tuple, array or object that contain arrays.
+*/
+type KeyOfArrayPath<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly (infer TItem)[] ? number extends TValue["length"] ? IsOrHasArray<TItem> extends true ? number : never : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? IsOrHasArray<TValue[TKey]> extends true ? TIndex : never : never }[number] : TValue extends Record<string, unknown> ? { [TKey in keyof TValue]: IsOrHasArray<TValue[TKey]> extends true ? TKey : never }[keyof TValue] & PathKey : never;
+/**
+* Lazily evaluate 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<MergeUnion<TValue>[TFirstKey], TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<KeyOfArrayPath<TValue>> extends false ? readonly [...TValidPath, KeyOfArrayPath<TValue>] : never;
+/**
+* Returns the path if valid, otherwise the first possible valid array path based on
+* the given value.
+*/
+type ValidArrayPath<TValue, TPath extends RequiredPath> = TPath extends LazyArrayPath<TValue, TPath> ? TPath : LazyArrayPath<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.
+* 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
+*/
+//#endregion
+//#region ../../packages/methods/dist/index.qwik.d.ts
+//#region src/focus/focus.d.ts
+interface FocusFieldConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  readonly form: BaseFormStore<TSchema>;
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+}
+declare function focus<TSchema extends Schema, TFieldPath extends RequiredPath>(config: FocusFieldConfig<TSchema, TFieldPath>): void;
+//#endregion
+//#region src/getAllErrors/getAllErrors.d.ts
+declare function getAllErrors(form: BaseFormStore): [string, ...string[]] | null;
+//#endregion
+//#region src/getErrors/getErrors.d.ts
+interface GetFormErrorsConfig {
+  readonly path?: undefined;
+}
+interface GetFieldErrorsConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+}
+declare function getErrors<TSchema extends Schema>(form: BaseFormStore<TSchema>): [string, ...string[]] | null;
+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
+interface GetFormInputConfig {
+  readonly path?: undefined;
+}
+interface GetFieldInputConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+}
+declare function getInput<TSchema extends Schema>(form: BaseFormStore<TSchema>): PartialValues<v.InferInput<TSchema>>;
+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/insert/insert.d.ts
+interface InsertConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  readonly at?: number | undefined;
+  readonly initialInput?: DeepPartial<PathValue<v.InferInput<TSchema>, [...TFieldArrayPath, number]>> | undefined;
+}
+declare function insert<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: InsertConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/move/move.d.ts
+interface MoveConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  readonly from: number;
+  readonly to: number;
+}
+declare function move<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: MoveConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/remove/remove.d.ts
+interface RemoveConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  readonly at: number;
+}
+declare function remove<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: RemoveConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/replace/replace.d.ts
+interface ReplaceConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  readonly at: number;
+  readonly initialInput?: DeepPartial<PathValue<v.InferInput<TSchema>, [...TFieldArrayPath, number]>> | undefined;
+}
+declare function replace<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: ReplaceConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/reset/reset.d.ts
+interface ResetBaseConfig {
+  readonly keepInput?: boolean | undefined;
+  readonly keepTouched?: boolean | undefined;
+  readonly keepErrors?: boolean | undefined;
+}
+interface ResetFormConfig<TSchema extends Schema> extends ResetBaseConfig {
+  readonly path?: undefined;
+  readonly initialInput?: DeepPartial<v.InferInput<TSchema>> | undefined;
+  readonly keepSubmitCount?: boolean | undefined;
+  readonly keepSubmitted?: boolean | undefined;
+}
+interface ResetFieldConfig<TSchema extends Schema, TFieldPath extends RequiredPath> extends ResetBaseConfig {
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  readonly initialInput?: DeepPartial<PathValue<v.InferInput<TSchema>, TFieldPath>>;
+}
+declare function reset(form: BaseFormStore): void;
+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
+interface SetFormErrorsConfig {
+  readonly path?: undefined;
+  readonly errors: [string, ...string[]] | null;
+}
+interface SetFieldErrorsConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  readonly errors: [string, ...string[]] | null;
+}
+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
+interface SetFormInputConfig<TSchema extends Schema> {
+  readonly path?: undefined;
+  readonly input: v.InferInput<TSchema>;
+}
+interface SetFieldInputConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  readonly input: PathValue<v.InferInput<TSchema>, TFieldPath>;
+}
+declare function setInput<TSchema extends Schema>(form: BaseFormStore<TSchema>, config: SetFormInputConfig<TSchema>): void;
+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
+declare function submit(form: BaseFormStore): void;
+//#endregion
+//#region src/swap/swap.d.ts
+interface SwapConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  readonly at: number;
+  readonly and: number;
+}
+declare function swap<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: SwapConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/validate/validate.d.ts
+interface ValidateFormConfig {
+  readonly shouldFocus?: boolean | undefined;
+}
+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.
+ */
+interface FieldElementProps {
+  readonly name: string;
+  readonly autofocus: boolean;
+  readonly ref: QRL<(element: FieldElement) => void>;
+  readonly onFocus$: QRL<(event: FocusEvent, element: FieldElement) => void>;
+  readonly onInput$: QRL<(event: InputEvent, element: FieldElement) => void>;
+  readonly onChange$: QRL<(event: Event, element: FieldElement) => void>;
+  readonly onBlur$: QRL<(event: FocusEvent, element: FieldElement) => void>;
+}
+/**
+ * Value type of the field store.
+ */
+interface FieldStore<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
+  readonly path: ReadonlySignal<ValidPath<v.InferInput<TSchema>, TFieldPath>>;
+  readonly input: ReadonlySignal<PartialValues<PathValue<v.InferInput<TSchema>, TFieldPath>>>;
+  readonly errors: ReadonlySignal<[string, ...string[]] | null>;
+  readonly isTouched: ReadonlySignal<boolean>;
+  readonly isDirty: ReadonlySignal<boolean>;
+  readonly isValid: ReadonlySignal<boolean>;
+  readonly props: FieldElementProps;
+}
+/**
+ * Value type of the field array store.
+ */
+interface FieldArrayStore<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
+  readonly path: ReadonlySignal<ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>>;
+  readonly items: ReadonlySignal<string[]>;
+  readonly errors: ReadonlySignal<[string, ...string[]] | null>;
+  readonly isTouched: ReadonlySignal<boolean>;
+  readonly isDirty: ReadonlySignal<boolean>;
+  readonly isValid: ReadonlySignal<boolean>;
+}
+//#endregion
+//#region src/types/form.d.ts
+interface FormStore<TSchema extends Schema = Schema> extends BaseFormStore<TSchema> {
+  readonly isSubmitting: ReadonlySignal<boolean>;
+  readonly isSubmitted: ReadonlySignal<boolean>;
+  readonly isValidating: ReadonlySignal<boolean>;
+  readonly isTouched: ReadonlySignal<boolean>;
+  readonly isDirty: ReadonlySignal<boolean>;
+  readonly isValid: ReadonlySignal<boolean>;
+  readonly errors: ReadonlySignal<[string, ...string[]] | null>;
+}
+//#endregion
+//#region src/components/Field/Field.d.ts
+/**
+ * Properties of the `Field` component.
+ */
+interface FieldProps<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
+  readonly of: FormStore<TSchema>;
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  readonly render$: QRL<(store: FieldStore<TSchema, TFieldPath>) => JSXOutput>;
+}
+/**
+ * Headless form field that provides reactive properties and state.
+ */
+declare const Field: <TSchema extends Schema, TFieldPath extends RequiredPath>(props: _qwik_dev_core_internal3.PublicProps<FieldProps<TSchema, TFieldPath>>, key: string | null, flags: number, dev?: _qwik_dev_core_internal3.DevJSX) => JSXOutput;
+//#endregion
+//#region src/components/FieldArray/FieldArray.d.ts
+/**
+ * Properties of the `FieldArray` component.
+ */
+interface FieldArrayProps<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
+  readonly of: FormStore<TSchema>;
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  readonly render$: QRL<(store: FieldArrayStore<TSchema, TFieldArrayPath>) => JSXOutput>;
+}
+/**
+ * Headless field array that provides reactive properties and state.
+ */
+declare const FieldArray: <TSchema extends Schema, TFieldArrayPath extends RequiredPath>(props: _qwik_dev_core_internal3.PublicProps<FieldArrayProps<TSchema, TFieldArrayPath>>, key: string | null, flags: number, dev?: _qwik_dev_core_internal3.DevJSX) => JSXOutput;
+//#endregion
+//#region src/components/Form/Form.d.ts
+type FormProps<TSchema extends Schema = Schema> = Omit<PropsOf<'form'>, 'onSubmit$'> & {
+  of: FormStore<TSchema>;
+  onSubmit$: QRL<SubmitHandler<TSchema>>;
+};
+declare const Form: <TSchema extends Schema>(props: _qwik_dev_core_internal3.PublicProps<FormProps<TSchema>>, key: string | null, flags: number, dev?: _qwik_dev_core_internal3.DevJSX) => JSXOutput;
+//#endregion
+//#region src/hooks/useField/useField.d.ts
+interface UseFieldConfig<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+}
+declare function useField<TSchema extends Schema, TFieldPath extends RequiredPath>(form: FormStore<TSchema>, config: UseFieldConfig<TSchema, TFieldPath>): FieldStore<TSchema, TFieldPath>;
+//#endregion
+//#region src/hooks/useFieldArray/useFieldArray.d.ts
+interface UseFieldArrayConfig<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+}
+declare function useFieldArray<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: FormStore<TSchema>, config: UseFieldArrayConfig<TSchema, TFieldArrayPath>): FieldArrayStore<TSchema, TFieldArrayPath>;
+//#endregion
+//#region src/hooks/useForm$/useForm$.d.ts
+declare function useFormQrl<TSchema extends Schema>(configQrl: QRL<FormConfig<TSchema>>): FormStore<TSchema>;
+declare const useForm$: <TSchema extends Schema>(qrl: FormConfig<TSchema>) => FormStore<TSchema>;
+//#endregion
+export { Field, FieldArray, FieldArrayProps, FieldArrayStore, FieldElementProps, FieldProps, FieldStore, FocusFieldConfig, Form, FormProps, FormStore, GetFieldErrorsConfig, GetFieldInputConfig, GetFormErrorsConfig, GetFormInputConfig, InsertConfig, MoveConfig, RemoveConfig, ReplaceConfig, ResetFieldConfig, ResetFormConfig, SetFieldErrorsConfig, SetFieldInputConfig, SetFormErrorsConfig, SetFormInputConfig, SwapConfig, UseFieldArrayConfig, UseFieldConfig, ValidateFormConfig, focus, getAllErrors, getErrors, getInput, insert, move, remove, replace, reset, setErrors, setInput, submit, swap, useField, useFieldArray, useForm$, useFormQrl, validate };