import * as Atom from "@effect-atom/atom/Atom";
import type * as Registry from "@effect-atom/atom/Registry";
import { Field, FormAtoms } from "@lucas-barake/effect-form";
import type { FieldState as FieldStateModule, Mode } from "@lucas-barake/effect-form";
import type * as FormBuilder from "@lucas-barake/effect-form/FormBuilder";
import type * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import type * as ParseResult from "effect/ParseResult";
import type * as Schema from "effect/Schema";
import * as React from "react";
export type FieldValue<T> = FieldStateModule.FieldValue<T>;
export type FieldState<E> = FieldStateModule.FieldState<E>;
export type ArrayFieldOperations<TItem> = FieldStateModule.ArrayFieldOperations<TItem>;
export interface FieldComponentProps<E, P = Record<string, never>> {
    readonly field: FieldState<E>;
    readonly props: P;
}
export type FieldComponent<T, P = Record<string, never>> = React.FC<FieldComponentProps<FieldValue<T>, P>>;
export type ExtractExtraProps<C> = C extends React.FC<FieldComponentProps<any, infer P>> ? P : Record<string, never>;
type StructFieldsFromSchema<S> = S extends Schema.Struct<infer Fields> ? Fields : S extends {
    readonly from: infer From;
} ? StructFieldsFromSchema<From> : never;
export type ArrayItemComponentMap<S extends Schema.Schema.Any> = StructFieldsFromSchema<S> extends Schema.Struct.Fields ? {
    readonly [K in keyof StructFieldsFromSchema<S>]: StructFieldsFromSchema<S>[K] extends Schema.Schema.Any ? React.FC<FieldComponentProps<Schema.Schema.Encoded<StructFieldsFromSchema<S>[K]>, any>> : never;
} : React.FC<FieldComponentProps<Schema.Schema.Encoded<S>, any>>;
export type FieldComponentMap<TFields extends Field.FieldsRecord> = {
    readonly [K in keyof TFields]: TFields[K] extends Field.FieldDef<any, infer S> ? React.FC<FieldComponentProps<Schema.Schema.Encoded<S>, any>> : TFields[K] extends Field.ArrayFieldDef<any, infer S> ? ArrayItemComponentMap<S> : never;
};
export type FieldRefs<TFields extends Field.FieldsRecord> = FormAtoms.FieldRefs<TFields>;
export type BuiltForm<TFields extends Field.FieldsRecord, R, A = void, E = never, SubmitArgs = void, CM extends FieldComponentMap<TFields> = FieldComponentMap<TFields>> = {
    readonly values: Atom.Atom<Option.Option<Field.EncodedFromFields<TFields>>>;
    readonly isDirty: Atom.Atom<boolean>;
    readonly hasChangedSinceSubmit: Atom.Atom<boolean>;
    readonly lastSubmittedValues: Atom.Atom<Option.Option<FormBuilder.SubmittedValues<TFields>>>;
    readonly submitCount: Atom.Atom<number>;
    readonly validationCount: Atom.Atom<number>;
    readonly schema: Schema.Schema<Field.DecodedFromFields<TFields>, Field.EncodedFromFields<TFields>, R>;
    readonly fields: FieldRefs<TFields>;
    readonly Initialize: React.FC<{
        readonly defaultValues: Field.EncodedFromFields<TFields>;
        readonly validateOnInit?: boolean;
        readonly children: React.ReactNode;
    }>;
    readonly submit: Atom.AtomResultFn<SubmitArgs, A, E | ParseResult.ParseError>;
    readonly validate: Atom.AtomResultFn<void, void, never>;
    readonly reset: Atom.Writable<void, void>;
    readonly revertToLastSubmit: Atom.Writable<void, void>;
    readonly setValues: Atom.Writable<Field.EncodedFromFields<TFields>>;
    readonly getFieldAtoms: <S>(field: FormBuilder.FieldRef<S>) => FormAtoms.PublicFieldAtoms<S>;
    readonly mount: Atom.Atom<void>;
    readonly KeepAlive: React.FC;
} & FieldComponents<TFields, CM>;
type FieldComponents<TFields extends Field.FieldsRecord, CM extends FieldComponentMap<TFields>> = {
    readonly [K in keyof TFields]: TFields[K] extends Field.FieldDef<any, any> ? React.FC<ExtractExtraProps<CM[K]>> : TFields[K] extends Field.ArrayFieldDef<any, infer S> ? ArrayFieldComponent<S, ExtractArrayItemExtraProps<CM[K], S>> : never;
};
type ExtractArrayItemExtraProps<CM, S extends Schema.Schema.Any> = StructFieldsFromSchema<S> extends Schema.Struct.Fields ? {
    readonly [K in keyof StructFieldsFromSchema<S>]: CM extends {
        readonly [P in K]: infer C;
    } ? ExtractExtraProps<C> : never;
} : CM extends React.FC<FieldComponentProps<any, infer P>> ? P : never;
type ArrayFieldComponent<S extends Schema.Schema.Any, ExtraPropsMap> = React.FC<{
    readonly children: (ops: ArrayFieldOperations<Schema.Schema.Encoded<S>>) => React.ReactNode;
}> & {
    readonly Item: React.FC<{
        readonly index: number;
        readonly children: React.ReactNode | ((props: {
            readonly remove: () => void;
        }) => React.ReactNode);
    }>;
} & (StructFieldsFromSchema<S> extends Schema.Struct.Fields ? {
    readonly [K in keyof StructFieldsFromSchema<S>]: React.FC<ExtraPropsMap extends {
        readonly [P in K]: infer EP;
    } ? EP : Record<string, never>>;
} : unknown);
export declare const make: {
    <TFields extends Field.FieldsRecord, R extends Registry.AtomRegistry, A, E, SubmitArgs = void, CM extends FieldComponentMap<TFields> = FieldComponentMap<TFields>>(self: FormBuilder.FormBuilder<TFields, R>, options: {
        readonly runtime?: Atom.AtomRuntime<any, any>;
        readonly fields: CM;
        readonly mode?: SubmitArgs extends void ? Mode.FormMode : Mode.FormModeWithoutAutoSubmit;
        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>;
    }): BuiltForm<TFields, R, A, E, SubmitArgs, CM>;
    <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = void, ER = never, CM extends FieldComponentMap<TFields> = FieldComponentMap<TFields>>(self: FormBuilder.FormBuilder<TFields, R>, options: {
        readonly runtime: Atom.AtomRuntime<R, ER>;
        readonly fields: CM;
        readonly mode?: SubmitArgs extends void ? Mode.FormMode : Mode.FormModeWithoutAutoSubmit;
        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>;
    }): BuiltForm<TFields, R, A, E, SubmitArgs, CM>;
};
export {};
//# sourceMappingURL=FormReact.d.ts.map