@formisch/svelte 0.1.0

package/dist/core/index.svelte.js

@@ -0,0 +1,445 @@
+import * as v from "valibot";
+import { untrack } from "svelte";
+
+//#region src/framework/index.svelte.ts
+const framework = "svelte";
+function createId() {
+	return Math.random().toString(36).slice(2);
+}
+function createSignal(initialValue) {
+	let signal = $state.raw(initialValue);
+	return {
+		get value() {
+			return signal;
+		},
+		set value(nextValue) {
+			signal = nextValue;
+		}
+	};
+}
+function batch(fn) {
+	return fn();
+}
+
+//#endregion
+//#region src/field/initializeFieldStore/initializeFieldStore.ts
+/**
+* TODO: Add comment
+* TODO: Should this stay in /primitives or move to /utils?
+*/
+function initializeFieldStore(internalFieldStore, schema, initialInput, path) {
+	if (framework === "qwik" && schema.type === "lazy" || schema.type === "object_with_rest" || schema.type === "record" || schema.type === "tuple_with_rest" || schema.type === "promise") throw new Error(`"${schema.type}" schema is not supported`);
+	else if (schema.type === "lazy") initializeFieldStore(internalFieldStore, schema.getter(void 0), initialInput, path);
+	else if (schema.type === "exact_optional" || schema.type === "non_nullable" || schema.type === "non_nullish" || schema.type === "non_optional" || schema.type === "nullable" || schema.type === "nullish" || schema.type === "optional" || schema.type === "undefinedable") initializeFieldStore(internalFieldStore, schema.wrapped, initialInput ?? v.getDefault(schema), path);
+	else if (schema.type === "intersect" || schema.type === "union" || schema.type === "variant") for (const schemaOption of schema.options) initializeFieldStore(internalFieldStore, schemaOption, initialInput, path);
+	else {
+		internalFieldStore.schema = schema;
+		internalFieldStore.name = JSON.stringify(path);
+		internalFieldStore.elements = [];
+		internalFieldStore.errors = createSignal(null);
+		if (schema.type === "array" || schema.type === "loose_tuple" || schema.type === "strict_tuple" || schema.type === "tuple") {
+			if (internalFieldStore.kind && internalFieldStore.kind !== "array") throw new Error(`Store initialized as "${internalFieldStore.kind}" cannot be reinitialized as "array"`);
+			internalFieldStore.kind = "array";
+			if (internalFieldStore.kind === "array") {
+				internalFieldStore.children ??= [];
+				if (schema.type === "array") {
+					if (initialInput) for (let index = 0; index < initialInput.length; index++) {
+						internalFieldStore.children[index] = {};
+						path.push(index);
+						initializeFieldStore(internalFieldStore.children[index], schema.item, initialInput[index], path);
+						path.pop();
+					}
+				} else for (let index = 0; index < schema.items; index++) {
+					internalFieldStore.children[index] = {};
+					path.push(index);
+					initializeFieldStore(internalFieldStore.children[index], schema.items[index], initialInput && initialInput[index], path);
+					path.pop();
+				}
+				const initialItems = internalFieldStore.children.map(createId);
+				internalFieldStore.initialItems = createSignal(initialItems);
+				internalFieldStore.startItems = createSignal(initialItems);
+				internalFieldStore.items = createSignal(initialItems);
+				internalFieldStore.isTouched = createSignal(false);
+				internalFieldStore.isDirty = createSignal(false);
+			}
+		} else if (schema.type === "loose_object" || schema.type === "object" || schema.type === "strict_object") {
+			if (internalFieldStore.kind && internalFieldStore.kind !== "object") throw new Error(`Store initialized as "${internalFieldStore.kind}" cannot be reinitialized as "object"`);
+			internalFieldStore.kind = "object";
+			if (internalFieldStore.kind === "object") {
+				internalFieldStore.children ??= {};
+				for (const key in schema.entries) {
+					internalFieldStore.children[key] = {};
+					path.push(key);
+					initializeFieldStore(internalFieldStore.children[key], schema.entries[key], initialInput && initialInput[key], path);
+					path.pop();
+				}
+			}
+		} else {
+			internalFieldStore.kind = "value";
+			if (internalFieldStore.kind === "value") {
+				internalFieldStore.initialInput = createSignal(initialInput);
+				internalFieldStore.startInput = createSignal(initialInput);
+				internalFieldStore.input = createSignal(initialInput);
+				internalFieldStore.isTouched = createSignal(false);
+				internalFieldStore.isDirty = createSignal(false);
+			}
+		}
+	}
+}
+
+//#endregion
+//#region src/array/copyItemState/copyItemState.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
+*/
+function copyItemState(fromInternalFieldStore, toInternalFieldStore) {
+	batch(() => {
+		untrack(() => {
+			if (fromInternalFieldStore.kind === "array" && toInternalFieldStore.kind === "array") {
+				const fromItems = fromInternalFieldStore.items.value;
+				toInternalFieldStore.isTouched.value = fromInternalFieldStore.isTouched.value;
+				toInternalFieldStore.isDirty.value = fromInternalFieldStore.isDirty.value;
+				toInternalFieldStore.startItems.value = fromInternalFieldStore.startItems.value;
+				toInternalFieldStore.items.value = fromItems;
+				let path;
+				for (let index = 0; index < fromItems.length; index++) {
+					if (!toInternalFieldStore.children[index]) {
+						path ??= JSON.parse(toInternalFieldStore.name);
+						toInternalFieldStore.children[index] = {};
+						path.push(index);
+						initializeFieldStore(toInternalFieldStore.children[index], toInternalFieldStore.schema.item, void 0, path);
+						path.pop();
+					}
+					copyItemState(fromInternalFieldStore.children[index], toInternalFieldStore.children[index]);
+				}
+			} else if (fromInternalFieldStore.kind === "object" && toInternalFieldStore.kind === "object") for (const key in fromInternalFieldStore.children) copyItemState(fromInternalFieldStore.children[key], toInternalFieldStore.children[key]);
+			else if (fromInternalFieldStore.kind === "value" && toInternalFieldStore.kind === "value") {
+				toInternalFieldStore.isTouched.value = fromInternalFieldStore.isTouched.value;
+				toInternalFieldStore.isDirty.value = fromInternalFieldStore.isDirty.value;
+				toInternalFieldStore.startInput.value = fromInternalFieldStore.startInput.value;
+				toInternalFieldStore.input.value = fromInternalFieldStore.input.value;
+			}
+		});
+	});
+}
+
+//#endregion
+//#region src/array/resetItemState/resetItemState.ts
+/**
+* Resets the state of an array item (signal values) deeply nested.
+* Sets `isTouched` and `isDirty` to `false` and `startInput`, `input`,
+* `startItems` and `items` to the new input.
+* Keeps the `initialInput` and `initialItems` state unchanged for form reset functionality.
+*
+* @param internalFieldStore - The field store of the array item
+* @param initialInput - The new input value (can be any type including array or object)
+*/
+function resetItemState(internalFieldStore, initialInput) {
+	batch(() => {
+		internalFieldStore.errors.value = null;
+		if (internalFieldStore.kind === "array") {
+			internalFieldStore.isTouched.value = false;
+			internalFieldStore.isDirty.value = false;
+			if (initialInput) {
+				const newItems = initialInput.map(createId);
+				internalFieldStore.startItems.value = newItems;
+				internalFieldStore.items.value = newItems;
+				for (let index = 0; index < initialInput.length; index++) if (internalFieldStore.children[index]) resetItemState(internalFieldStore.children[index], initialInput[index]);
+			} else {
+				internalFieldStore.startItems.value = [];
+				internalFieldStore.items.value = [];
+			}
+		} else if (internalFieldStore.kind === "object") for (const key in internalFieldStore.children) resetItemState(internalFieldStore.children[key], initialInput?.[key]);
+		else {
+			internalFieldStore.isTouched.value = false;
+			internalFieldStore.isDirty.value = false;
+			internalFieldStore.startInput.value = initialInput;
+			internalFieldStore.input.value = initialInput;
+		}
+	});
+}
+
+//#endregion
+//#region src/array/swapItemState/swapItemState.ts
+/**
+* Swaps the deeply nested state (signal values) between two field stores.
+* This includes the `isTouched`, `isDirty`, `startInput`, `input`, `startItems`, and `items` properties.
+* Recursively walks through the field stores and swaps all signal values.
+*
+* @param firstInternalFieldStore - The first field store to swap
+* @param secondInternalFieldStore - The second field store to swap
+*/
+function swapItemState(firstInternalFieldStore, secondInternalFieldStore) {
+	batch(() => {
+		untrack(() => {
+			if (firstInternalFieldStore.kind === "array" && secondInternalFieldStore.kind === "array") {
+				const firstItems = firstInternalFieldStore.items.value;
+				const secondItems = secondInternalFieldStore.items.value;
+				const tempIsTouched = firstInternalFieldStore.isTouched.value;
+				firstInternalFieldStore.isTouched.value = secondInternalFieldStore.isTouched.value;
+				secondInternalFieldStore.isTouched.value = tempIsTouched;
+				const tempIsDirty = firstInternalFieldStore.isDirty.value;
+				firstInternalFieldStore.isDirty.value = secondInternalFieldStore.isDirty.value;
+				secondInternalFieldStore.isDirty.value = tempIsDirty;
+				const tempStartItems = firstInternalFieldStore.startItems.value;
+				firstInternalFieldStore.startItems.value = secondInternalFieldStore.startItems.value;
+				secondInternalFieldStore.startItems.value = tempStartItems;
+				firstInternalFieldStore.items.value = secondItems;
+				secondInternalFieldStore.items.value = firstItems;
+				const maxLength = Math.max(firstItems.length, secondItems.length);
+				let firstPath;
+				let secondPath;
+				for (let index = 0; index < maxLength; index++) {
+					if (!firstInternalFieldStore.children[index]) {
+						firstPath ??= JSON.parse(firstInternalFieldStore.name);
+						firstInternalFieldStore.children[index] = {};
+						firstPath.push(index);
+						initializeFieldStore(firstInternalFieldStore.children[index], firstInternalFieldStore.schema.item, void 0, firstPath);
+						firstPath.pop();
+					}
+					if (!secondInternalFieldStore.children[index]) {
+						secondPath ??= JSON.parse(secondInternalFieldStore.name);
+						secondInternalFieldStore.children[index] = {};
+						secondPath.push(index);
+						initializeFieldStore(secondInternalFieldStore.children[index], secondInternalFieldStore.schema.item, void 0, secondPath);
+						secondPath.pop();
+					}
+					swapItemState(firstInternalFieldStore.children[index], secondInternalFieldStore.children[index]);
+				}
+			} else if (firstInternalFieldStore.kind === "object" && secondInternalFieldStore.kind === "object") for (const key in firstInternalFieldStore.children) swapItemState(firstInternalFieldStore.children[key], secondInternalFieldStore.children[key]);
+			else if (firstInternalFieldStore.kind === "value" && secondInternalFieldStore.kind === "value") {
+				const tempIsTouched = firstInternalFieldStore.isTouched.value;
+				firstInternalFieldStore.isTouched.value = secondInternalFieldStore.isTouched.value;
+				secondInternalFieldStore.isTouched.value = tempIsTouched;
+				const tempIsDirty = firstInternalFieldStore.isDirty.value;
+				firstInternalFieldStore.isDirty.value = secondInternalFieldStore.isDirty.value;
+				secondInternalFieldStore.isDirty.value = tempIsDirty;
+				const tempStartInput = firstInternalFieldStore.startInput.value;
+				firstInternalFieldStore.startInput.value = secondInternalFieldStore.startInput.value;
+				secondInternalFieldStore.startInput.value = tempStartInput;
+				const tempInput = firstInternalFieldStore.input.value;
+				firstInternalFieldStore.input.value = secondInternalFieldStore.input.value;
+				secondInternalFieldStore.input.value = tempInput;
+			}
+		});
+	});
+}
+
+//#endregion
+//#region src/field/getFieldInput/getFieldInput.ts
+function getFieldInput(internalFieldStore) {
+	if (internalFieldStore.kind === "array") {
+		const value = [];
+		for (let index = 0; index < internalFieldStore.items.value.length; index++) value[index] = getFieldInput(internalFieldStore.children[index]);
+		return value;
+	}
+	if (internalFieldStore.kind === "object") {
+		const value = {};
+		for (const key in internalFieldStore.children) value[key] = getFieldInput(internalFieldStore.children[key]);
+		return value;
+	}
+	return internalFieldStore.input.value;
+}
+
+//#endregion
+//#region src/field/getElementInput/getElementInput.ts
+/**
+* Returns the current input of the element.
+*
+* @param element The field element.
+* @param interalFieldStore The interal field store.
+*
+* @returns The element input.
+*/
+function getElementInput(element, internalFieldStore) {
+	if (element.options && element.multiple) return [...element.options].filter((option) => option.selected && !option.disabled).map((option) => option.value);
+	if (element.type === "checkbox") {
+		const options = document.getElementsByName(element.name);
+		if (options.length > 1) return [...options].filter((option) => option.checked).map((option) => option.value);
+		return element.checked;
+	}
+	if (element.type === "radio") {
+		const prevValue = untrack(() => getFieldInput(internalFieldStore));
+		if (element.checked) return [...prevValue, element.value];
+		return prevValue.filter((value) => value !== element.value);
+	}
+	if (element.type === "file") {
+		if (element.multiple) return [...element.files];
+		return element.files[0];
+	}
+	return element.value;
+}
+
+//#endregion
+//#region src/field/getFieldBool/getFieldBool.ts
+function getFieldBool(internalFieldStore, type) {
+	if (internalFieldStore.kind === "array") {
+		if (internalFieldStore[type].value) return true;
+		for (let index = 0; index < internalFieldStore.items.value.length; index++) if (getFieldBool(internalFieldStore.children[index], type)) return true;
+		return false;
+	}
+	if (internalFieldStore.kind == "object") {
+		if (type === "errors" && internalFieldStore[type].value) return true;
+		for (const key in internalFieldStore.children) if (getFieldBool(internalFieldStore.children[key], type)) return true;
+		return false;
+	}
+	return !!internalFieldStore[type].value;
+}
+
+//#endregion
+//#region src/field/getFieldStore/getFieldStore.ts
+function getFieldStore(internalFormStore, path) {
+	let internalFieldStore = internalFormStore;
+	for (const key of path) internalFieldStore = internalFieldStore.children[key];
+	return internalFieldStore;
+}
+
+//#endregion
+//#region src/field/setFieldBool/setFieldBool.ts
+function setFieldBool(internalFieldStore, type, bool) {
+	batch(() => {
+		if (internalFieldStore.kind === "array") {
+			internalFieldStore[type].value = bool;
+			for (let index = 0; index < untrack(() => internalFieldStore.items.value).length; index++) setFieldBool(internalFieldStore.children[index], type, bool);
+		} else if (internalFieldStore.kind == "object") for (const key in internalFieldStore.children) setFieldBool(internalFieldStore.children[key], type, bool);
+		else internalFieldStore[type].value = bool;
+	});
+}
+
+//#endregion
+//#region src/field/setFieldInput/setFieldInput.ts
+function setFieldInput(internalFieldStore, input) {
+	batch(() => {
+		if (internalFieldStore.kind === "array") {
+			const items = untrack(() => internalFieldStore.items.value);
+			if (input.length < items.length) internalFieldStore.items.value = items.slice(0, input.length);
+			else if (input.length > items.length) {
+				if (input.length > internalFieldStore.children.length) {
+					const path = JSON.parse(internalFieldStore.name);
+					for (let index = internalFieldStore.children.length; index < input.length; index++) {
+						internalFieldStore.children[index] = {};
+						path.push(index);
+						initializeFieldStore(internalFieldStore.children[index], internalFieldStore.schema.item, input[index], path);
+						path.pop();
+					}
+				}
+				internalFieldStore.items.value = [...items, ...input.slice(items.length).map(createId)];
+			}
+			for (let index = 0; index < items.length; index++) setFieldInput(internalFieldStore.children[index], input[index]);
+			internalFieldStore.isDirty.value = untrack(() => internalFieldStore.startItems.value).length !== items.length;
+		} else if (internalFieldStore.kind === "object") for (const key in internalFieldStore.children) setFieldInput(internalFieldStore.children[key], input[key]);
+		else {
+			internalFieldStore.input.value = input;
+			internalFieldStore.isTouched.value = true;
+			const startInput = untrack(() => internalFieldStore.startInput.value);
+			internalFieldStore.isDirty.value = startInput !== input && (startInput !== void 0 || input !== "" && !Number.isNaN(input));
+		}
+	});
+}
+
+//#endregion
+//#region src/field/setInitialFieldInput/setInitialFieldInput.ts
+function setInitialFieldInput(internalFieldStore, initialInput) {
+	batch(() => {
+		if (internalFieldStore.kind === "array") {
+			if (initialInput.length > internalFieldStore.children.length) {
+				const path = JSON.parse(internalFieldStore.name);
+				for (let index = internalFieldStore.children.length; index < initialInput.length; index++) {
+					internalFieldStore.children[index] = {};
+					path.push(index);
+					initializeFieldStore(internalFieldStore.children[index], internalFieldStore.schema.item, initialInput[index], path);
+					path.pop();
+				}
+			}
+			internalFieldStore.initialItems.value = initialInput.map(createId);
+			for (let index = 0; index < internalFieldStore.children.length; index++) setInitialFieldInput(internalFieldStore.children[index], initialInput?.[index]);
+		} else if (internalFieldStore.kind === "object") for (const key in internalFieldStore.children) setInitialFieldInput(internalFieldStore.children[key], initialInput?.[key]);
+		else internalFieldStore.initialInput.value = initialInput;
+	});
+}
+
+//#endregion
+//#region src/field/walkFieldStore/walkFieldStore.ts
+function walkFieldStore(internalFieldStore, callback) {
+	callback(internalFieldStore);
+	if (internalFieldStore.kind === "array") for (let index = 0; index < untrack(() => internalFieldStore.items.value).length; index++) walkFieldStore(internalFieldStore.children[index], callback);
+	else if (internalFieldStore.kind === "object") for (const key in internalFieldStore.children) walkFieldStore(internalFieldStore.children[key], callback);
+}
+
+//#endregion
+//#region src/form/createFormStore/createFormStore.ts
+function createFormStore(config, parse) {
+	const store = {};
+	initializeFieldStore(store, config.schema, config.initialInput, []);
+	store.validate = config.validate ?? "submit";
+	store.revalidate = config.revalidate ?? "input";
+	store.parse = parse;
+	store.isSubmitting = createSignal(false);
+	store.isSubmitted = createSignal(false);
+	store.isValidating = createSignal(false);
+	return store;
+}
+
+//#endregion
+//#region src/form/validateFormInput/validateFormInput.ts
+async function validateFormInput(internalFormStore, config) {
+	internalFormStore.validators++;
+	internalFormStore.isValidating.value = true;
+	const result = await internalFormStore.parse(untrack(() => getFieldInput(internalFormStore)));
+	let rootErrors;
+	let nestedErrors;
+	if (result.issues) {
+		nestedErrors = {};
+		for (const issue of result.issues) if (issue.path) {
+			const path = [];
+			for (const pathItem of issue.path) {
+				const key = pathItem.key;
+				const keyType = typeof key;
+				const itemType = pathItem.type;
+				if (keyType !== "string" && keyType !== "number" || itemType === "map" || itemType === "set") break;
+				path.push(key);
+			}
+			const name = JSON.stringify(path);
+			const fieldErrors = nestedErrors[name];
+			if (fieldErrors) fieldErrors.push(issue.message);
+			else nestedErrors[name] = [issue.message];
+		} else if (rootErrors) rootErrors.push(issue.message);
+		else rootErrors = [issue.message];
+	}
+	let shouldFocus = config?.shouldFocus ?? false;
+	batch(() => {
+		walkFieldStore(internalFormStore, (internalFieldStore) => {
+			if (internalFieldStore.name === "[]") internalFieldStore.errors.value = rootErrors ?? null;
+			else {
+				const fieldErrors = nestedErrors?.[internalFieldStore.name] ?? null;
+				internalFieldStore.errors.value = fieldErrors;
+				if (shouldFocus && fieldErrors) {
+					internalFieldStore.elements[0]?.focus();
+					shouldFocus = false;
+				}
+			}
+		});
+		internalFormStore.validators--;
+		internalFormStore.isValidating.value = internalFormStore.validators > 0;
+	});
+	return result;
+}
+
+//#endregion
+//#region src/form/validateIfRequired/validateIfRequired.ts
+function validateIfRequired(internalFormStore, internalFieldStore, validationModes) {
+	if (validationModes === (internalFormStore.validate === "initial" || (internalFormStore.validate === "submit" ? untrack(() => internalFormStore.isSubmitted.value) : untrack(() => getFieldBool(internalFieldStore, "errors"))) ? internalFormStore.revalidate : internalFormStore.validate)) validateFormInput(internalFormStore);
+}
+
+//#endregion
+//#region src/values.ts
+const INTERNAL = "~internal";
+
+//#endregion
+export { INTERNAL, batch, copyItemState, createFormStore, createId, createSignal, framework, getElementInput, getFieldBool, getFieldInput, getFieldStore, initializeFieldStore, resetItemState, setFieldBool, setFieldInput, setInitialFieldInput, swapItemState, untrack, validateFormInput, validateIfRequired, walkFieldStore };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type { SubmitHandler } from './core/index.svelte';
+export * from './methods/index.svelte';
+export * from './components/index.ts';
+export * from './runes/index.ts';
+export * from './types/index.ts';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './methods/index.svelte';
+export * from './components/index';
+export * from './runes/index';
+export * from './types/index';

package/dist/methods/index.svelte.d.ts

@@ -0,0 +1,127 @@
+import { BaseFormStore, DeepPartial, PartialValues, PathValue, RequiredPath, Schema, SubmitHandler, ValidArrayPath, ValidPath } from "../core/index.svelte";
+import * as v from "valibot";
+
+//#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/handleSubmit/handleSubmit.d.ts
+declare function handleSubmit<TSchema extends Schema>(form: BaseFormStore<TSchema>, handler: SubmitHandler<TSchema>): (event: SubmitEvent) => void;
+//#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
+export { FocusFieldConfig, GetFieldErrorsConfig, GetFieldInputConfig, GetFormErrorsConfig, GetFormInputConfig, InsertConfig, MoveConfig, RemoveConfig, ReplaceConfig, ResetFieldConfig, ResetFormConfig, SetFieldErrorsConfig, SetFieldInputConfig, SetFormErrorsConfig, SetFormInputConfig, SwapConfig, ValidateFormConfig, focus, getAllErrors, getErrors, getInput, handleSubmit, insert, move, remove, replace, reset, setErrors, setInput, submit, swap, validate };