import * as Atom from "@effect-atom/atom/Atom";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import * as ParseResult from "effect/ParseResult";
import * as Schema from "effect/Schema";
import * as Field from "./Field.ts";
import * as FormBuilder from "./FormBuilder.ts";
import { type WeakRegistry } from "./internal/weak-registry.ts";
import * as Mode from "./Mode.ts";
import * as Validation from "./Validation.ts";
export interface FieldAtoms {
    readonly valueAtom: Atom.Writable<unknown, unknown>;
    readonly initialValueAtom: Atom.Atom<unknown>;
    readonly touchedAtom: Atom.Writable<boolean, boolean>;
    readonly errorAtom: Atom.Atom<Option.Option<Validation.ErrorEntry>>;
    readonly isDirtyAtom: Atom.Atom<boolean>;
    readonly validationAtom: Atom.AtomResultFn<unknown, void, ParseResult.ParseError>;
    readonly displayErrorAtom: Atom.Atom<Option.Option<string>>;
    readonly fieldValidationCountAtom: Atom.Writable<number, number>;
    readonly shouldValidateAtom: Atom.Atom<boolean>;
    readonly triggerValidationAtom: Atom.Atom<void>;
}
export interface PublicFieldAtoms<E> {
    readonly value: Atom.Atom<Option.Option<E>>;
    readonly error: Atom.Atom<Option.Option<string>>;
    readonly isDirty: Atom.Atom<boolean>;
    readonly isTouched: Atom.Atom<boolean>;
    readonly isValidating: Atom.Atom<boolean>;
    readonly setValue: Atom.Writable<void, E | ((prev: E) => E)>;
    readonly setTouched: Atom.Writable<void, boolean>;
    readonly validate: Atom.Writable<void, void>;
}
export interface FormAtomsConfig<TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = void> {
    readonly runtime: Atom.AtomRuntime<R, any>;
    readonly formBuilder: FormBuilder.FormBuilder<TFields, R>;
    readonly mode?: Mode.FormMode;
    readonly reactivityKeys?: ReadonlyArray<unknown> | Readonly<Record<string, ReadonlyArray<unknown>>> | undefined;
    readonly onSubmit: (args: SubmitArgs, ctx: {
        readonly decoded: Field.DecodedFromFields<TFields>;
        readonly encoded: Field.EncodedFromFields<TFields>;
        readonly get: Atom.FnContext;
    }) => A | Effect.Effect<A, E, R>;
}
export type FieldRefs<TFields extends Field.FieldsRecord> = {
    readonly [K in keyof TFields]: TFields[K] extends Field.FieldDef<any, infer S> ? FormBuilder.FieldRef<Schema.Schema.Encoded<S>> : TFields[K] extends Field.ArrayFieldDef<any, infer S> ? FormBuilder.FieldRef<ReadonlyArray<Schema.Schema.Encoded<S>>> : never;
};
export interface FormAtoms<TFields extends Field.FieldsRecord, R, A = void, E = never, SubmitArgs = void> {
    readonly stateAtom: Atom.Writable<Option.Option<FormBuilder.FormState<TFields>>, Option.Option<FormBuilder.FormState<TFields>>>;
    readonly errorsAtom: Atom.Writable<Map<string, Validation.ErrorEntry>, Map<string, Validation.ErrorEntry>>;
    readonly rootErrorAtom: Atom.Atom<Option.Option<string>>;
    readonly valuesAtom: Atom.Atom<Option.Option<Field.EncodedFromFields<TFields>>>;
    readonly dirtyFieldsAtom: Atom.Atom<ReadonlySet<string>>;
    readonly isDirtyAtom: Atom.Atom<boolean>;
    readonly submitCountAtom: Atom.Atom<number>;
    readonly validationCountAtom: Atom.Atom<number>;
    readonly lastSubmittedValuesAtom: Atom.Atom<Option.Option<FormBuilder.SubmittedValues<TFields>>>;
    readonly changedSinceSubmitFieldsAtom: Atom.Atom<ReadonlySet<string>>;
    readonly hasChangedSinceSubmitAtom: Atom.Atom<boolean>;
    readonly submitAtom: Atom.AtomResultFn<SubmitArgs, A, E | ParseResult.ParseError>;
    readonly validateAtom: Atom.AtomResultFn<void, void, never>;
    readonly combinedSchema: Schema.Schema<Field.DecodedFromFields<TFields>, Field.EncodedFromFields<TFields>, R>;
    readonly fieldRefs: FieldRefs<TFields>;
    readonly validationAtomsRegistry: WeakRegistry<Atom.AtomResultFn<unknown, void, ParseResult.ParseError>>;
    readonly fieldAtomsRegistry: WeakRegistry<FieldAtoms>;
    readonly getOrCreateValidationAtom: (fieldPath: string, schema: Schema.Schema.Any) => Atom.AtomResultFn<unknown, void, ParseResult.ParseError>;
    readonly getOrCreateFieldAtoms: (fieldPath: string, schema: Schema.Schema.Any) => FieldAtoms;
    readonly resetValidationAtoms: (ctx: {
        set: <R, W>(atom: Atom.Writable<R, W>, value: W) => void;
    }) => void;
    readonly operations: FormOperations<TFields>;
    readonly resetAtom: Atom.Writable<void, void>;
    readonly revertToLastSubmitAtom: Atom.Writable<void, void>;
    readonly setValuesAtom: Atom.Writable<Field.EncodedFromFields<TFields>>;
    readonly getFieldAtoms: <S>(field: FormBuilder.FieldRef<S>) => PublicFieldAtoms<S>;
    /**
     * Root anchor atom for the form's dependency graph.
     * Mount this atom to keep all form state alive even when field components unmount.
     *
     * Useful for:
     * - Multi-step wizards where steps unmount but state should persist
     * - Conditional fields (toggles) where state should survive visibility changes
     *
     * @example
     * ```tsx
     * // Keep form state alive at wizard root level
     * function Wizard() {
     *   useAtomMount(step1Form.mount)
     *   useAtomMount(step2Form.mount)
     *   return currentStep === 1 ? <Step1 /> : <Step2 />
     * }
     * ```
     */
    readonly autoSubmitAtom: Atom.Atom<void>;
    readonly onBlurSubmitAtom: Atom.Writable<void, void>;
    readonly mountAtom: Atom.Atom<void>;
    readonly keepAliveActiveAtom: Atom.Writable<boolean, boolean>;
}
export interface FormOperations<TFields extends Field.FieldsRecord> {
    readonly createInitialState: (defaultValues: Field.EncodedFromFields<TFields>) => FormBuilder.FormState<TFields>;
    readonly createResetState: (state: FormBuilder.FormState<TFields>) => FormBuilder.FormState<TFields>;
    readonly createSubmitState: (state: FormBuilder.FormState<TFields>) => FormBuilder.FormState<TFields>;
    readonly setFieldValue: (state: FormBuilder.FormState<TFields>, fieldPath: string, value: unknown) => FormBuilder.FormState<TFields>;
    readonly setFormValues: (state: FormBuilder.FormState<TFields>, values: Field.EncodedFromFields<TFields>) => FormBuilder.FormState<TFields>;
    readonly setFieldTouched: (state: FormBuilder.FormState<TFields>, fieldPath: string, touched: boolean) => FormBuilder.FormState<TFields>;
    readonly appendArrayItem: (state: FormBuilder.FormState<TFields>, arrayPath: string, itemSchema: Schema.Schema.Any, value?: unknown) => FormBuilder.FormState<TFields>;
    readonly removeArrayItem: (state: FormBuilder.FormState<TFields>, arrayPath: string, index: number) => FormBuilder.FormState<TFields>;
    readonly swapArrayItems: (state: FormBuilder.FormState<TFields>, arrayPath: string, indexA: number, indexB: number) => FormBuilder.FormState<TFields>;
    readonly moveArrayItem: (state: FormBuilder.FormState<TFields>, arrayPath: string, fromIndex: number, toIndex: number) => FormBuilder.FormState<TFields>;
    readonly revertToLastSubmit: (state: FormBuilder.FormState<TFields>) => FormBuilder.FormState<TFields>;
}
export declare const make: <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = void>(config: FormAtomsConfig<TFields, R, A, E, SubmitArgs>) => FormAtoms<TFields, R, A, E, SubmitArgs>;
//# sourceMappingURL=FormAtoms.d.ts.map