oxform-core 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,443 @@
+import * as _tanstack_store0 from "@tanstack/store";
+import { Derived, Store } from "@tanstack/store";
+import * as _standard_schema_spec1 from "@standard-schema/spec";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { PartialDeep, Simplify } from "type-fest";
+
+//#region src/more-types.d.ts
+/**
+ * @private
+ */
+type UnwrapOneLevelOfArray<T> = T extends (infer U)[] ? U : T;
+type Narrowable = string | number | bigint | boolean;
+type NarrowRaw<A> = (A extends [] ? [] : never) | (A extends Narrowable ? A : never) | { [K in keyof A]: A[K] extends Function ? A[K] : NarrowRaw<A[K]> };
+type Try<A1, A2, Catch = never> = A1 extends A2 ? A1 : Catch;
+/**
+ * @private
+ */
+type Narrow<A> = Try<A, [], NarrowRaw<A>>;
+interface AnyDeepKeyAndValue<K$1 extends string = string, V extends any = any> {
+  key: K$1;
+  value: V;
+}
+type ArrayAccessor<TParent extends AnyDeepKeyAndValue> = `${TParent['key'] extends never ? '' : TParent['key']}.${number}`;
+interface ArrayDeepKeyAndValue<in out TParent extends AnyDeepKeyAndValue, in out T extends ReadonlyArray<any>> extends AnyDeepKeyAndValue {
+  key: ArrayAccessor<TParent>;
+  value: T[number] | Nullable<TParent['value']>;
+}
+type DeepKeyAndValueArray<TParent extends AnyDeepKeyAndValue, T extends ReadonlyArray<any>, TAcc> = DeepKeysAndValuesImpl<NonNullable<T[number]>, ArrayDeepKeyAndValue<TParent, T>, TAcc | ArrayDeepKeyAndValue<TParent, T>>;
+type TupleAccessor<TParent extends AnyDeepKeyAndValue, TKey extends string> = `${TParent['key'] extends never ? '' : TParent['key']}[${TKey}]`;
+interface TupleDeepKeyAndValue<in out TParent extends AnyDeepKeyAndValue, in out T, in out TKey extends AllTupleKeys<T>> extends AnyDeepKeyAndValue {
+  key: TupleAccessor<TParent, TKey>;
+  value: T[TKey] | Nullable<TParent['value']>;
+}
+type AllTupleKeys<T> = T extends any ? keyof T & `${number}` : never;
+type DeepKeyAndValueTuple<TParent extends AnyDeepKeyAndValue, T extends ReadonlyArray<any>, TAcc, TAllKeys extends AllTupleKeys<T> = AllTupleKeys<T>> = TAllKeys extends any ? DeepKeysAndValuesImpl<NonNullable<T[TAllKeys]>, TupleDeepKeyAndValue<TParent, T, TAllKeys>, TAcc | TupleDeepKeyAndValue<TParent, T, TAllKeys>> : never;
+type AllObjectKeys<T> = T extends any ? keyof T & (string | number) : never;
+type ObjectAccessor<TParent extends AnyDeepKeyAndValue, TKey extends string | number> = TParent['key'] extends never ? `${TKey}` : `${TParent['key']}.${TKey}`;
+type Nullable<T> = T & (undefined | null);
+type ObjectValue<TParent extends AnyDeepKeyAndValue, T, TKey extends AllObjectKeys<T>> = T[TKey] | Nullable<TParent['value']>;
+interface ObjectDeepKeyAndValue<in out TParent extends AnyDeepKeyAndValue, in out T, in out TKey extends AllObjectKeys<T>> extends AnyDeepKeyAndValue {
+  key: ObjectAccessor<TParent, TKey>;
+  value: ObjectValue<TParent, T, TKey>;
+}
+type DeepKeyAndValueObject<TParent extends AnyDeepKeyAndValue, T, TAcc, TAllKeys extends AllObjectKeys<T> = AllObjectKeys<T>> = TAllKeys extends any ? DeepKeysAndValuesImpl<NonNullable<T[TAllKeys]>, ObjectDeepKeyAndValue<TParent, T, TAllKeys>, TAcc | ObjectDeepKeyAndValue<TParent, T, TAllKeys>> : never;
+type UnknownAccessor<TParent extends AnyDeepKeyAndValue> = TParent['key'] extends never ? string : `${TParent['key']}.${string}`;
+interface UnknownDeepKeyAndValue<TParent extends AnyDeepKeyAndValue> extends AnyDeepKeyAndValue {
+  key: UnknownAccessor<TParent>;
+  value: unknown;
+}
+type DeepKeysAndValues<T> = DeepKeysAndValuesImpl<T> extends AnyDeepKeyAndValue ? DeepKeysAndValuesImpl<T> : never;
+type DeepKeysAndValuesImpl<T, TParent extends AnyDeepKeyAndValue = never, TAcc = never> = unknown extends T ? TAcc | UnknownDeepKeyAndValue<TParent> : unknown extends T ? T : T extends string | number | boolean | bigint | Date ? TAcc : T extends ReadonlyArray<any> ? number extends T['length'] ? DeepKeyAndValueArray<TParent, T, TAcc> : DeepKeyAndValueTuple<TParent, T, TAcc> : keyof T extends never ? TAcc | UnknownDeepKeyAndValue<TParent> : T extends object ? DeepKeyAndValueObject<TParent, T, TAcc> : TAcc;
+type DeepRecord<T> = { [TRecord in DeepKeysAndValues<T> as TRecord['key']]: TRecord['value'] };
+/**
+ * The keys of an object or array, deeply nested.
+ */
+type DeepKeys<T> = unknown extends T ? string : DeepKeysAndValues<T>['key'];
+/**
+ * Infer the type of a deeply nested property within an object or an array.
+ */
+type DeepValue<TValue, TAccessor> = unknown extends TValue ? TValue : TAccessor extends DeepKeys<TValue> ? DeepRecord<TValue>[TAccessor] : never;
+/**
+ * The keys of an object or array, deeply nested and only with a value of TValue
+ */
+type DeepKeysOfType<TData, TValue> = Extract<DeepKeysAndValues<TData>, AnyDeepKeyAndValue<string, TValue>>['key'];
+/**
+ * Maps the deep keys of TFormData to the shallow keys of TFieldGroupData.
+ *  Since using template strings as keys is impractical, it relies on shallow keys only.
+ */
+type FieldsMap<TFormData, TFieldGroupData> = TFieldGroupData extends any[] ? never : string extends keyof TFieldGroupData ? never : { [K in keyof TFieldGroupData]: DeepKeysOfType<TFormData, TFieldGroupData[K]> };
+//#endregion
+//#region src/types.d.ts
+type EventLike = {
+  target?: {
+    value: any;
+  };
+};
+type ArrayLike = any[] | undefined | null;
+//#endregion
+//#region src/form-api.types.d.ts
+type PersistedFormStatus = {
+  submits: number;
+  submitting: boolean;
+  validating: boolean;
+  successful: boolean;
+  dirty: boolean;
+};
+type FormStatus = Simplify<PersistedFormStatus & {
+  submitted: boolean;
+  valid: boolean;
+}>;
+type PersistedFieldMeta = {
+  blurred: boolean;
+  touched: boolean;
+  dirty: boolean;
+};
+type FieldMeta = Simplify<PersistedFieldMeta & {
+  touched: boolean;
+  default: boolean;
+  valid: boolean;
+  pristine: boolean;
+}>;
+type FormBaseStore<Values> = {
+  values: Values;
+  fields: Record<string, PersistedFieldMeta>;
+  refs: Record<string, HTMLElement | null>;
+  status: PersistedFormStatus;
+  errors: Record<string, FormIssue[]>;
+};
+type FormStore<Values> = {
+  values: Values;
+  fields: Record<string, FieldMeta>;
+  refs: Record<string, HTMLElement | null>;
+  status: FormStatus;
+  errors: Record<string, FormIssue[]>;
+};
+type FieldControl<Value> = {
+  focus: () => void;
+  blur: () => void;
+  change: (value: Value) => void;
+  register: (element: HTMLElement | null) => void;
+};
+type FormValidatorSchema<Values> = StandardSchemaV1<PartialDeep<Values>>;
+type FormValidatorFunction<Values> = (store: FormStore<Values>) => FormValidatorSchema<Values>;
+type FormValidator<Values> = FormValidatorSchema<Values> | FormValidatorFunction<Values>;
+type FormOptions<Values> = {
+  schema: StandardSchemaV1<Values>;
+  values?: Values;
+  defaultValues: Values;
+  validate?: {
+    change?: FormValidator<Values>;
+    submit?: FormValidator<Values>;
+    blur?: FormValidator<Values>;
+    focus?: FormValidator<Values>;
+  };
+  related?: Record<DeepKeys<Values>, DeepKeys<Values>[]>;
+};
+type FormIssue = StandardSchemaV1.Issue;
+type ValidationType = 'change' | 'submit' | 'blur' | 'focus';
+type ValidateOptions = {
+  type?: ValidationType;
+};
+type FieldChangeOptions = {
+  should?: {
+    /** Whether to validate the field after changing its value. Defaults to true. */
+    validate?: boolean;
+    /** Whether to mark the field as dirty after changing its value. Defaults to true. */
+    dirty?: boolean;
+    /** Whether to mark the field as touched after changing its value. Defaults to true. */
+    touch?: boolean;
+  };
+};
+type FieldResetMeta = {
+  blurred?: boolean;
+  touched?: boolean;
+  dirty?: boolean;
+};
+type FieldResetKeepOptions = {
+  errors?: boolean;
+  refs?: boolean;
+  meta?: boolean;
+};
+type FormResetFieldOptions<Value> = {
+  value?: Value;
+  meta?: FieldResetMeta;
+  keep?: FieldResetKeepOptions;
+};
+type FormResetKeepOptions = {
+  /** Keep current field errors */
+  errors?: boolean;
+  /** Keep current references to html input elements */
+  refs?: boolean;
+  /** Keep current field metadata */
+  fields?: boolean;
+};
+type FormResetOptions<Values> = {
+  values?: Values;
+  status?: Partial<PersistedFormStatus>;
+  keep?: FormResetKeepOptions;
+};
+type FieldSetErrorsMode = 'replace' | 'append' | 'keep';
+type FormSetErrorsOptions = {
+  mode?: FieldSetErrorsMode;
+};
+type FormSubmitSuccessHandler<Schema extends StandardSchemaV1> = (data: StandardSchemaV1.InferOutput<Schema>, form: FormApi<Schema>) => void | Promise<void>;
+type FormSubmitErrorHandler<Schema extends StandardSchemaV1> = (issues: FormIssue[], form: FormApi<Schema>) => void | Promise<void>;
+type FormSubmitHandlers<Schema extends StandardSchemaV1> = {
+  onSuccess: FormSubmitSuccessHandler<Schema>;
+  onError?: FormSubmitErrorHandler<Schema>;
+};
+//#endregion
+//#region src/form-context-api.d.ts
+declare class FormContextApi<Values> {
+  options: FormOptions<Values>;
+  persisted: Store<FormBaseStore<Values>>;
+  store: Derived<FormStore<Values>>;
+  constructor(options: FormOptions<Values>);
+  get status(): {
+    submits: number;
+    submitting: boolean;
+    validating: boolean;
+    successful: boolean;
+    dirty: boolean;
+    submitted: boolean;
+    valid: boolean;
+  };
+  get values(): Values;
+  private get validator();
+  buildFieldMeta: (fieldName: string, persistedMeta: PersistedFieldMeta | undefined, values: Values, errors: Record<string, FormIssue[]>) => FieldMeta;
+  setFieldMeta: (name: string, meta: Partial<PersistedFieldMeta>) => void;
+  resetFieldMeta: (name: string) => void;
+  recomputeFieldMeta: (name: string) => void;
+  setStatus: (status: Partial<PersistedFormStatus>) => void;
+  validate: (field?: FormFields<FormApi<Values>> | FormFields<FormApi<Values>>[], options?: ValidateOptions) => Promise<_standard_schema_spec1.StandardSchemaV1.Issue[]>;
+}
+//#endregion
+//#region src/utils/update.d.ts
+type UpdaterFn<TInput, TOutput = TInput> = (input: TInput) => TOutput;
+type Updater<TInput, TOutput = TInput> = TOutput | UpdaterFn<TInput, TOutput>;
+//#endregion
+//#region src/form-field-api.d.ts
+declare class FormFieldApi<Values> {
+  private context;
+  constructor(context: FormContextApi<Values>);
+  /**
+   * Changes the value of a specific field with optional control over side effects.
+   * @param name - The name of the field to change
+   * @param value - The new value to set for the field
+   * @param options - Optional configuration for controlling validation, dirty state, and touched state
+   */
+  change: <const Name extends FormFields<FormApi<Values>>>(name: Name, updater: Updater<DeepValue<Values, Name>>, options?: FieldChangeOptions) => void;
+  focus: <const Name extends FormFields<FormApi<Values>>>(name: Name) => void;
+  blur: <const Name extends FormFields<FormApi<Values>>>(name: Name) => void;
+  get: <const Name extends FormFields<FormApi<Values>>>(name: Name) => DeepValue<Values, Name>;
+  meta: <const Name extends FormFields<FormApi<Values>>>(name: Name) => {
+    blurred: boolean;
+    touched: boolean;
+    dirty: boolean;
+    default: boolean;
+    valid: boolean;
+    pristine: boolean;
+  };
+  register: <const Name extends FormFields<FormApi<Values>>>(name: Name) => (element: HTMLElement | null) => void;
+  errors: <const Name extends FormFields<FormApi<Values>>>(name: Name) => _standard_schema_spec1.StandardSchemaV1.Issue[];
+  setErrors: <const Name extends FormFields<FormApi<Values>>>(name: Name, errors: FormIssue[], options?: FormSetErrorsOptions) => void;
+  reset: <const Name extends FormFields<FormApi<Values>>>(name: Name, options?: FormResetFieldOptions<DeepValue<Values, Name>>) => void;
+}
+//#endregion
+//#region src/form-array-field-api.d.ts
+declare class FormArrayFieldApi<Values> {
+  private context;
+  private field;
+  constructor({
+    field,
+    context
+  }: {
+    field: FormFieldApi<Values>;
+    context: FormContextApi<Values>;
+  });
+  insert: <const Name extends FormArrayFields<FormApi<Values>>>(name: Name, index: number, value: Updater<UnwrapOneLevelOfArray<DeepValue<Values, Name>>>, options?: FieldChangeOptions) => void;
+  append: <const Name extends FormArrayFields<FormApi<Values>>>(name: Name, value: UnwrapOneLevelOfArray<DeepValue<Values, Name>>, options?: FieldChangeOptions) => void;
+  prepend: <const Name extends FormArrayFields<FormApi<Values>>>(name: Name, value: UnwrapOneLevelOfArray<DeepValue<Values, Name>>, options?: FieldChangeOptions) => void;
+  swap: <const Name extends FormArrayFields<FormApi<Values>>>(name: Name, from: number, to: number, options?: FieldChangeOptions) => void;
+  move<const Name extends FormArrayFields<FormApi<Values>>>(name: Name, _from: number, _to: number, options?: FieldChangeOptions): void;
+  update: <const Name extends FormArrayFields<FormApi<Values>>>(name: Name, index: number, value: Updater<UnwrapOneLevelOfArray<DeepValue<Values, Name>>>, options?: FieldChangeOptions) => void;
+  remove<const Name extends FormArrayFields<FormApi<Values>>>(name: Name, index: number, options?: FieldChangeOptions): void;
+  replace<const Name extends FormArrayFields<FormApi<Values>>>(name: Name, value: Updater<DeepValue<Values, Name>>, options?: FieldChangeOptions): void;
+}
+//#endregion
+//#region src/form-api.d.ts
+type AnyFormApi = FormApi<any>;
+type FormValues<Form extends AnyFormApi> = Form extends FormApi<infer Values> ? Values : never;
+type FormFields<Form extends AnyFormApi> = DeepKeys<FormValues<Form>>;
+type FormArrayFields<Form extends AnyFormApi> = DeepKeysOfType<FormValues<Form>, ArrayLike>;
+type FormFieldValue<Form extends AnyFormApi, Name extends FormFields<Form>> = DeepValue<FormValues<Form>, Name>;
+declare class FormApi<Values> {
+  private context;
+  field: FormFieldApi<Values>;
+  array: FormArrayFieldApi<Values>;
+  constructor(options: FormOptions<Values>);
+  '~mount': () => () => void;
+  '~update': (options: FormOptions<Values>) => void;
+  store: () => _tanstack_store0.Derived<FormStore<Values>, readonly any[]>;
+  status: () => {
+    submits: number;
+    submitting: boolean;
+    validating: boolean;
+    successful: boolean;
+    dirty: boolean;
+    submitted: boolean;
+    valid: boolean;
+  };
+  values: () => Values;
+  options: () => FormOptions<Values>;
+  get validate(): (field?: DeepKeys<Values> | DeepKeys<Values>[] | undefined, options?: ValidateOptions) => Promise<StandardSchemaV1.Issue[]>;
+  submit: (onSuccess: FormSubmitSuccessHandler<StandardSchemaV1<Values>>, onError?: FormSubmitErrorHandler<StandardSchemaV1<Values>>) => () => Promise<void>;
+  reset: (options?: FormResetOptions<Values>) => void;
+}
+//#endregion
+//#region src/field-api.d.ts
+type FieldOptions<Form extends AnyFormApi, Name extends FormFields<Form>> = {
+  form: Form;
+  name: Name;
+};
+type FieldState<Value> = {
+  value: Value;
+  defaultValue: Value;
+  meta: FieldMeta;
+  errors: FormIssue[];
+};
+type AnyFieldApi = FieldApi<any>;
+declare class FieldApi<Value> {
+  private _options;
+  private form;
+  private _store;
+  constructor(options: FieldOptions<AnyFormApi, string>);
+  '~mount': () => () => void;
+  '~update': (options: FieldOptions<AnyFormApi, string>) => void;
+  options: () => FieldOptions<AnyFormApi, string>;
+  store: () => Derived<FieldState<Value>, readonly any[]>;
+  state: () => FieldState<Value>;
+  focus: () => void;
+  blur: () => void;
+  /**
+   * Changes the value of this field with optional control over side effects.
+   * @param value - The new value to set for the field
+   * @param options - Optional configuration for controlling validation, dirty state, and touched state
+   */
+  change: (value: Updater<Value>, options?: FieldChangeOptions) => void;
+  register: () => (element: HTMLElement | null) => void;
+  /**
+   * Validates this specific field using the specified validation type.
+   * @param options - Optional validation options specifying the validation type ('change' | 'submit' | 'blur' | 'focus')
+   * @returns Promise resolving to an array of validation issues for this field
+   */
+  validate: (options?: ValidateOptions) => Promise<_standard_schema_spec1.StandardSchemaV1.Issue[]>;
+  /**
+   * Resets this field to its default value and optionally resets metadata and errors.
+   * @param options - Reset options for controlling what gets reset and what gets kept
+   */
+  reset: (options?: FormResetFieldOptions<Value>) => void;
+  /**
+   * Sets validation errors for this specific field.
+   * @param errors - Array of validation errors to set
+   * @param mode - How to handle existing errors: 'replace' (default), 'append', or 'keep'
+   */
+  setErrors: (errors: FormIssue[], options?: FormSetErrorsOptions) => void;
+}
+declare const createFieldApi: <Form extends AnyFormApi, const Name extends FormFields<Form>>(options: FieldOptions<Form, Name>) => FieldApi<FormFieldValue<Form, Name>>;
+//#endregion
+//#region src/array-field-api.d.ts
+type ArrayFieldOptions<Form extends AnyFormApi, Name extends FormArrayFields<Form>> = {
+  form: Form;
+  name: Name;
+};
+type AnyArrayFieldApi = ArrayFieldApi<any>;
+declare class ArrayFieldApi<Value extends ArrayLike> {
+  private field;
+  constructor(options: FieldOptions<AnyFormApi, string>);
+  private get _options();
+  '~mount': () => () => void;
+  '~update': (options: FieldOptions<AnyFormApi, string>) => void;
+  store: () => _tanstack_store0.Derived<FieldState<Value>, readonly any[]>;
+  state: () => FieldState<Value>;
+  /**
+   * Appends a new item to the end of the array.
+   * @param value - The value to append to the array
+   * @param options - Optional configuration for controlling validation, dirty state, and touched state
+   */
+  append: (value: UnwrapOneLevelOfArray<Value>, options?: FieldChangeOptions) => void;
+  /**
+   * Prepends a new item to the beginning of the array.
+   * @param value - The value to prepend to the array
+   * @param options - Optional configuration for controlling validation, dirty state, and touched state
+   */
+  prepend: (value: UnwrapOneLevelOfArray<Value>, options?: FieldChangeOptions) => void;
+  /**
+   * Inserts a new item at the specified index in the array.
+   * @param index - The index at which to insert the value
+   * @param value - The value to insert into the array
+   * @param options - Optional configuration for controlling validation, dirty state, and touched state
+   */
+  insert: (index: number, value: Updater<UnwrapOneLevelOfArray<Value>>, options?: FieldChangeOptions) => void;
+  /**
+   * Updates an item at the specified index in the array.
+   * @param index - The index of the item to update
+   * @param value - The new value or updater function
+   * @param options - Optional configuration for controlling validation, dirty state, and touched state
+   */
+  update: (index: number, value: Updater<UnwrapOneLevelOfArray<Value>>, options?: FieldChangeOptions) => void;
+  /**
+   * Removes an item at the specified index from the array.
+   * @param index - The index of the item to remove
+   * @param options - Optional configuration for controlling validation, dirty state, and touched state
+   */
+  remove: (index: number, options?: FieldChangeOptions) => void;
+  /**
+   * Swaps two items in the array by their indices.
+   * @param from - The index of the first item
+   * @param to - The index of the second item
+   * @param options - Optional configuration for controlling validation, dirty state, and touched state
+   */
+  swap: (from: number, to: number, options?: FieldChangeOptions) => void;
+  /**
+   * Moves an item from one index to another in the array.
+   * @param from - The index of the item to move
+   * @param to - The target index
+   * @param options - Optional configuration for controlling validation, dirty state, and touched state
+   */
+  move: (from: number, to: number, options?: FieldChangeOptions) => void;
+  /**
+   * Replaces the entire array with a new value.
+   * @param value - The new array value or updater function
+   * @param options - Optional configuration for controlling validation, dirty state, and touched state
+   */
+  replace: (value: Updater<Value>, options?: FieldChangeOptions) => void;
+  /**
+   * Validates this specific array field using the specified validation type.
+   * @param options - Optional validation options specifying the validation type ('change' | 'submit' | 'blur' | 'focus')
+   * @returns Promise resolving to an array of validation issues for this field
+   */
+  validate: (options?: ValidateOptions) => Promise<StandardSchemaV1.Issue[]>;
+  /**
+   * Resets this array field to its default value and optionally resets metadata and errors.
+   * @param options - Reset options for controlling what gets reset and what gets kept
+   */
+  reset: (options?: FormResetFieldOptions<Value>) => void;
+  /**
+   * Sets validation errors for this specific array field.
+   * @param errors - Array of validation errors to set
+   * @param mode - How to handle existing errors: 'replace' (default), 'append', or 'keep'
+   */
+  setErrors: (errors: FormIssue[], options?: FormSetErrorsOptions) => void;
+}
+declare const createArrayFieldApi: <FormApi$1 extends AnyFormApi, const Name extends FormArrayFields<FormApi$1>>(options: ArrayFieldOptions<FormApi$1, Name>) => ArrayFieldApi<FormFieldValue<FormApi$1, Name>>;
+//#endregion
+//#region src/types/any-form-like-api.d.ts
+type AnyFormLikeApi = AnyFormApi | AnyArrayFieldApi | AnyFieldApi;
+//#endregion
+//#region src/types/api-selector.d.ts
+type ApiSelector<Api extends AnyFormLikeApi, Selected> = (state: ReturnType<Api['store']>['state']) => Selected;
+//#endregion
+export { AllObjectKeys, AllTupleKeys, type AnyArrayFieldApi, AnyDeepKeyAndValue, type AnyFieldApi, type AnyFormApi, type AnyFormLikeApi, type ApiSelector, ArrayAccessor, ArrayDeepKeyAndValue, ArrayFieldApi, type ArrayFieldOptions, type ArrayLike, DeepKeyAndValueArray, DeepKeyAndValueObject, DeepKeyAndValueTuple, DeepKeys, DeepKeysAndValues, DeepKeysAndValuesImpl, DeepKeysOfType, DeepRecord, DeepValue, type EventLike, FieldApi, FieldChangeOptions, FieldControl, FieldMeta, type FieldOptions, FieldResetKeepOptions, FieldResetMeta, FieldSetErrorsMode, type FieldState, FieldsMap, FormApi, type FormArrayFields, FormBaseStore, type FormFieldValue, type FormFields, FormIssue, FormOptions, FormResetFieldOptions, FormResetKeepOptions, FormResetOptions, FormSetErrorsOptions, FormStatus, FormStore, FormSubmitErrorHandler, FormSubmitHandlers, FormSubmitSuccessHandler, type FormValues, Narrow, Nullable, ObjectAccessor, ObjectDeepKeyAndValue, ObjectValue, PersistedFieldMeta, PersistedFormStatus, type Simplify, type StandardSchemaV1 as StandardSchema, TupleAccessor, TupleDeepKeyAndValue, UnknownAccessor, UnknownDeepKeyAndValue, UnwrapOneLevelOfArray, ValidateOptions, ValidationType, createArrayFieldApi, createFieldApi };
+//# sourceMappingURL=index.d.ts.map