import type { FieldPath, FieldPathValue, FieldValues, IsEqual } from './path';
import type { ArrayProxy, DerivedStateProps, ObjectMutationMethods, ObjectStateValue, Prettify, ValueState } from './types';
export { type CreateFormOptions, createForm, type DeepNonNullable, type FormArrayState, type FormObjectState, type FormState, type FormStore, type FormValueState, useForm };
/**
 * Common form field methods available on every form state node.
 */
type FormCommon = {
    /** Subscribe and read the validation error. Re-renders when the error changes. */
    useError: () => string | undefined;
    /** Read the validation error without subscribing. */
    readonly error: string | undefined;
    /** Manually set a validation error. */
    setError: (error: string | undefined) => void;
};
type FormState<T> = IsEqual<T, unknown> extends true ? never : [NonNullable<T>] extends [readonly (infer U)[]] ? FormArrayState<U, T> : [NonNullable<T>] extends [FieldValues] ? FormObjectState<NonNullable<T>, T> : FormValueState<T>;
type FormReadOnlyState<T> = Prettify<Pick<FormValueState<Readonly<Required<T>>>, 'value' | 'use' | 'useCompute' | 'error' | 'setError'>>;
interface FormValueState<T> extends Omit<ValueState<T>, 'ensureArray' | 'ensureObject' | 'withDefault' | 'derived'>, FormCommon {
    /** Ensure the value is an array. */
    ensureArray(): NonNullable<T> extends (infer U)[] ? FormArrayState<U> : never;
    /** Ensure the value is an object. */
    ensureObject(): NonNullable<T> extends FieldValues ? FormObjectState<NonNullable<T>> : never;
    /** Return a new state with a default value, and make the type non-nullable */
    withDefault(defaultValue: T): FormState<NonNullable<T>>;
    /** Virtual state derived from the current value.
     *
     * @returns ArrayState if the derived value is an array, ObjectState if the derived value is an object, otherwise State.
     * @example
     * const state = store.a.b.c.derived({
     *   from: value => value + 1,
     *   to: value => value - 1
     * })
     * state.use() // returns the derived value
     * state.set(10) // sets the derived value
     * state.reset() // resets the derived value
     */
    derived: <R>({ from, to }: DerivedStateProps<T, R>) => FormState<R>;
}
type FormObjectProxy<T extends FieldValues, TObject = T> = {
    /** Virtual state for the object's keys.
     *
     * This does NOT read from a real `keys` property on the stored object; it results in a stable array of keys.
     */
    readonly keys: FormReadOnlyState<FieldPath<T>[]>;
} & {
    [K in keyof T]-?: FormState<ObjectStateValue<TObject, T, K>>;
};
type FormArrayState<TValue, TArray = TValue[]> = IsEqual<TValue, unknown> extends true ? never : FormValueState<TArray> & ArrayProxy<TValue, FormState<TValue>>;
type FormObjectState<TNonNullable extends FieldValues, TObject = TNonNullable> = FormObjectProxy<TNonNullable, TObject> & FormValueState<TObject> & ObjectMutationMethods;
/** Type for nested objects with proxy methods */
type DeepNonNullable<T> = [NonNullable<T>] extends [readonly (infer U)[]] ? U[] : [NonNullable<T>] extends [FieldValues] ? {
    [K in keyof NonNullable<T>]-?: DeepNonNullable<NonNullable<T>[K]>;
} : NonNullable<T>;
/**
 * The form store type, combining form state with validation and submission handling.
 */
type FormStore<T extends FieldValues> = FormState<T> & {
    /** Clears all validation errors from the form. */
    clearErrors(): void;
    /** Returns a form submit handler that validates and calls onSubmit with form values. */
    handleSubmit(onSubmit: (values: T) => void): (e: React.SyntheticEvent) => void;
};
type NoEmptyValidator = 'not-empty';
type RegexValidator = RegExp;
type FunctionValidator<T extends FieldValues> = (value: FieldPathValue<T, FieldPath<T>>, state: FormStore<T>) => string | undefined;
type Validator<T extends FieldValues> = NoEmptyValidator | RegexValidator | FunctionValidator<T>;
type FieldConfig<T extends FieldValues> = {
    validate?: Validator<T>;
};
type CreateFormOptions<T extends FieldValues> = Partial<Record<FieldPath<T>, FieldConfig<T>>>;
type UnsubscribeFn = () => void;
type UnsubscribeFns = UnsubscribeFn[];
/**
 * React hook that creates a form store with validation support.
 *
 * The form store extends the memory store with error handling and validation.
 * Fields can be configured with validators that run on every change.
 *
 * @param defaultValue - Initial form values
 * @param fieldConfigs - Optional validation configuration per field
 * @returns A form store with validation and submission handling
 *
 * @example
 * const form = useForm(
 *   { email: '', password: '' },
 *   {
 *     email: { validate: 'not-empty' },
 *     password: { validate: v => v && v.length < 8 ? 'Too short' : undefined }
 *   }
 * )
 *
 * <form onSubmit={form.handleSubmit(values => console.log(values))}>
 *   <input value={form.email.use() ?? ''} onChange={e => form.email.set(e.target.value)} />
 *   {form.email.useError() && <span>{form.email.error}</span>}
 * </form>
 */
declare function useForm<T extends FieldValues>(defaultValue: T, fieldConfigs?: CreateFormOptions<T>): FormStore<T>;
declare function createForm<T extends FieldValues>(namespace: string, defaultValue: T, fieldConfigs?: CreateFormOptions<T>): [FormStore<T>, UnsubscribeFns];