import { DependencyList, FocusEventHandler, ReactElement, ReactNode } from "react";
import type { Atom } from "../atom/index.js";
import type { EnsoUtils as Utils } from "../utils.ts";
declare const hintSymbol: unique symbol;
export declare class Field<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> extends Atom<"field", "exact", Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent> implements Utils.StaticImplements<typeof Field<Value, Qualifier, Parent>, Atom.Static.Subclass<"field">>, Field.Exact<Value, Qualifier, Parent> {
    static create<Value, Qualifier extends Atom.Qualifier.Constraint = Atom.Qualifier.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default>(value: Value, parent?: Atom.Parent.Ref<"field", Qualifier, Parent>): Atom.Envelop<"field", "exact", Atom.Def<Value>, Qualifier, Parent>;
    static base<Envelop extends Atom.Envelop<"field", any, any>>(field: Envelop): Atom.Base.Result<"field", Envelop>;
    static proxy<Variant extends Atom.Flavor.Variant, ValueDef extends Atom.Def.Constraint, ComputedValue, MappedValue, Qualifier extends Atom.Qualifier.Constraint, Parent extends Atom.Parent.Constraint<ValueDef>>(field: Field.Envelop<Variant, ValueDef, Qualifier, Parent>, intoMapper: Atom.Proxy.Into.Mapper<ValueDef, ComputedValue>, fromMapper: Atom.Proxy.From.Mapper<ValueDef, ComputedValue, MappedValue>): Atom.Proxy.Envelop<"field", Variant, ValueDef, ComputedValue, Qualifier, Parent>;
    static use<Value>(initialValue: Value, deps: DependencyList): Field.Exact<Value>;
    static useEnsure<FieldType extends Atom.Envelop<"field", any, any> | Utils.Falsy, MappedType extends Atom.Envelop<"field", any, any> | Utils.Falsy = undefined>(field: FieldType, map?: Atom.Static.Ensure.Mapper<"field", FieldType, MappedType>): Atom.Static.Ensure.Result<"field", FieldType, MappedType>;
    static Component<Value, MetaEnable extends boolean | undefined = undefined, DirtyEnable extends boolean = false, ErrorsEnable extends boolean = false, ValidEnable extends boolean = false>(props: Field.Component.Props<Value, MetaEnable, DirtyEnable, ErrorsEnable, ValidEnable>): ReactElement<HTMLElement>;
    [hintSymbol]: true;
    get dirty(): boolean;
    useDirty: Field.Dirty.Use.Prop<Atom.Qualifier.Internalize<Qualifier>>;
    commit: Field.Commit.Prop<Atom.Qualifier.Internalize<Qualifier>>;
    reset: Field.Reset.Prop<Atom.Qualifier.Internalize<Qualifier>>;
    readonly initial: Atom.Value.Prop<Atom.Def<Value>>;
    control<Element extends HTMLElement>(props?: Field.Control.Props<Element>): Field.Control.Registration<Element>;
    ref<Element extends HTMLElement>(element: Element | null): void;
    get errors(): Field.Error[];
    useErrors: Field.Errors.Use.Prop<Atom.Qualifier.Internalize<Qualifier>>;
    get valid(): boolean;
    useValid: Field.Valid.Use.Prop<Atom.Qualifier.Internalize<Qualifier>>;
    readonly validate: Field.Validate.Prop<Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>>;
    addError: Field.AddError.Prop;
    clearErrors(): void;
}
export declare namespace Field {
    type Envelop<Variant extends Atom.Flavor.Variant, ValueDef extends Atom.Def.Constraint, Qualifier extends Atom.Qualifier.Constraint, Parent extends Atom.Parent.Constraint<ValueDef>> = Variant extends "exact" ? Exact.Internal<ValueDef, Qualifier, Parent> : Variant extends "optional" ? Optional.Internal<ValueDef, Qualifier, Parent> : Variant extends "base" ? Base.Internal<ValueDef, Qualifier, Parent> : Variant extends "immutable" ? Immutable.Internal<ValueDef, Qualifier, Parent> : never;
    type Prop = "field";
    interface Exact<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> extends Exact.Internal<Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent> {
    }
    namespace Exact {
        interface Internal<ValueDef extends Atom.Def.Constraint, out Qualifier extends Atom.Qualifier.Constraint = Atom.Qualifier.Default, Parent extends Atom.Parent.Constraint<ValueDef> = Atom.Parent.Default> extends Ish.Value.Write<Qualifier>, Atom.Exact<"field", "exact", ValueDef, Qualifier, Parent>, Immutable.Interface<"exact", ValueDef, Qualifier, Parent> {
        }
        type Decomposed<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.Decompose.Result<"field", "exact", Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent>;
        type DecomposedVariant<Value, Variant extends Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Decomposed<Value, Qualifier, Parent> & {
            value: Variant;
        };
        type DecomposedNullish<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.DecomposeNullish.Result<"field", "exact", Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent>;
        type Discriminated<Value, Discriminator extends Atom.Discriminate.Discriminator<Atom.Def<Value>>, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.Discriminate.Result<"field", "exact", Atom.Def<Value>, Discriminator, Atom.Qualifier.Internalize<Qualifier>, Parent>;
        type DiscriminatedVariant<Value, Discriminator extends Atom.Discriminate.Discriminator<Atom.Def<Value>>, Variant extends Discriminator extends keyof Value ? Value[Discriminator] : never, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Discriminated<Value, Discriminator, Qualifier, Parent> & {
            discriminator: Variant;
        };
    }
    interface Base<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> extends Base.Internal<Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent> {
    }
    namespace Base {
        interface Internal<ValueDef extends Atom.Def.Constraint, out Qualifier extends Atom.Qualifier.Constraint = Atom.Qualifier.Default, Parent extends Atom.Parent.Constraint<ValueDef> = Atom.Parent.Default> extends Base.Interface<"base", ValueDef, Qualifier, Parent> {
        }
        interface Interface<Variant extends Atom.Flavor.Variant, ValueDef extends Atom.Def.Constraint, out Qualifier extends Atom.Qualifier.Constraint = Atom.Qualifier.Default, Parent extends Atom.Parent.Constraint<ValueDef> = Atom.Parent.Default> extends Immutable.Interface<Variant, ValueDef, Qualifier, Parent> {
        }
        type Decomposed<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.Decompose.Result<"field", "base", Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent>;
        type DecomposedVariant<Value, Variant extends Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Decomposed<Value, Qualifier, Parent> & {
            value: Variant;
        };
        type DecomposedNullish<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.DecomposeNullish.Result<"field", "base", Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent>;
        type Discriminated<Value, Discriminator extends Atom.Discriminate.Discriminator<Atom.Def<Value>>, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.Discriminate.Result<"field", "base", Atom.Def<Value>, Discriminator, Atom.Qualifier.Internalize<Qualifier>, Parent>;
        type DiscriminatedVariant<Value, Discriminator extends Atom.Discriminate.Discriminator<Atom.Def<Value>>, Variant extends Discriminator extends keyof Value ? Value[Discriminator] : never, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Discriminated<Value, Discriminator, Qualifier, Parent> & {
            discriminator: Variant;
        };
    }
    interface Optional<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> extends Optional.Internal<Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent> {
    }
    namespace Optional {
        interface Internal<ValueDef extends Atom.Def.Constraint, out Qualifier extends Atom.Qualifier.Constraint = Atom.Qualifier.Default, Parent extends Atom.Parent.Constraint<ValueDef> = Atom.Parent.Default> extends Optional.Interface<"optional", ValueDef, Qualifier, Parent> {
        }
        interface Interface<Variant extends Atom.Flavor.Variant, ValueDef extends Atom.Def.Constraint, out Qualifier extends Atom.Qualifier.Constraint = Atom.Qualifier.Default, Parent extends Atom.Parent.Constraint<ValueDef> = Atom.Parent.Default> extends Immutable.Interface<Variant, ValueDef, Qualifier, Parent> {
        }
        type Decomposed<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.Decompose.Result<"field", "optional", Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent>;
        type DecomposedVariant<Value, Variant extends Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Decomposed<Value, Qualifier, Parent> & {
            value: Variant;
        };
        type DecomposedNullish<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.DecomposeNullish.Result<"field", "optional", Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent>;
        type Discriminated<Value, Discriminator extends Atom.Discriminate.Discriminator<Atom.Def<Value>>, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.Discriminate.Result<"field", "optional", Atom.Def<Value>, Discriminator, Atom.Qualifier.Internalize<Qualifier>, Parent>;
        type DiscriminatedVariant<Value, Discriminator extends Atom.Discriminate.Discriminator<Atom.Def<Value>>, Variant extends Discriminator extends keyof Value ? Value[Discriminator] : never, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Discriminated<Value, Discriminator, Qualifier, Parent> & {
            discriminator: Variant;
        };
    }
    interface Immutable<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> extends Immutable.Internal<Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent> {
    }
    namespace Immutable {
        interface Internal<ValueDef extends Atom.Def.Constraint, out Qualifier extends Atom.Qualifier.Constraint = Atom.Qualifier.Default, Parent extends Atom.Parent.Constraint<ValueDef> = Atom.Parent.Default> extends Immutable.Interface<"immutable", ValueDef, Qualifier, Parent> {
        }
        interface Interface<Variant extends Atom.Flavor.Variant, ValueDef extends Atom.Def.Constraint, out Qualifier extends Atom.Qualifier.Constraint = Atom.Qualifier.Default, Parent extends Atom.Parent.Constraint<ValueDef> = Atom.Parent.Default> extends Ish.Value.Read<ValueDef, Qualifier>, Ish.Validation<ValueDef, Qualifier>, Atom.Immutable<"field", Variant, ValueDef, Qualifier, Parent> {
            [hintSymbol]: true;
            control<Element extends HTMLElement>(props?: Field.Control.Props<Element>): Field.Control.Registration<Element>;
            ref<Element extends HTMLElement>(element: Element | null): void;
            readonly validate: Field.Validate.Prop<ValueDef, Qualifier>;
        }
        type Decomposed<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.Decompose.Result<"field", "immutable", Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent>;
        type DecomposedVariant<Value, Variant extends Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Decomposed<Value, Qualifier, Parent> & {
            value: Variant;
        };
        type DecomposedNullish<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.DecomposeNullish.Result<"field", "immutable", Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent>;
        type Discriminated<Value, Discriminator extends Atom.Discriminate.Discriminator<Atom.Def<Value>>, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.Discriminate.Result<"field", "immutable", Atom.Def<Value>, Discriminator, Atom.Qualifier.Internalize<Qualifier>, Parent>;
        type DiscriminatedVariant<Value, Discriminator extends Atom.Discriminate.Discriminator<Atom.Def<Value>>, Variant extends Discriminator extends keyof Value ? Value[Discriminator] : never, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Discriminated<Value, Discriminator, Qualifier, Parent> & {
            discriminator: Variant;
        };
    }
    type Shared<ValueTuple extends Atom.Shared.Value.Tuple, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Shared.Def<ValueTuple>> = Atom.Parent.Default> = Shared.Exact<ValueTuple, Qualifier, Parent>;
    namespace Shared {
        type Def<ValueTuple extends Atom.Shared.Value.Tuple> = Atom.Shared.Def<ValueTuple>;
        type Proxy<ValueTuple extends Atom.Shared.Value.Tuple> = Atom.Proxy.Qualifier<Atom.Shared.Def<ValueTuple>>;
        type Exact<ValueTuple extends Atom.Shared.Value.Tuple, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Shared.Def<ValueTuple>> = Atom.Parent.Default> = Field.Exact.Internal<Atom.Shared.Def<ValueTuple>, Atom.Qualifier.Internalize<Qualifier>, Parent>;
        type Base<ValueTuple extends Atom.Shared.Value.Tuple, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Shared.Def<ValueTuple>> = Atom.Parent.Default> = Field.Base.Internal<Atom.Shared.Def<ValueTuple>, Atom.Qualifier.Internalize<Qualifier>, Parent>;
        type Immutable<ValueTuple extends Atom.Shared.Value.Tuple, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Shared.Def<ValueTuple>> = Atom.Parent.Default> = Field.Immutable.Internal<Atom.Shared.Def<ValueTuple>, Atom.Qualifier.Internalize<Qualifier>, Parent>;
    }
    type Ref<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Field.Immutable<Value, Utils.Transparent<Atom.Qualifier.External.Concat<Qualifier, "ref">>, Parent>;
    namespace Ref {
        type Optional<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Field.Optional<Value, Utils.Transparent<Atom.Qualifier.External.Concat<Qualifier, "ref">>, Parent>;
    }
    namespace Ish {
        namespace Value {
            interface Read<ValueDef extends Atom.Def.Constraint, out Qualifier extends Atom.Qualifier.Constraint> {
                readonly initial: Atom.Value.Prop<ValueDef>;
                dirty: boolean;
                useDirty: Dirty.Use.Prop<Qualifier>;
            }
            interface Write<out Qualifier extends Atom.Qualifier.Constraint> {
                commit: Commit.Prop<Qualifier>;
                reset: Reset.Prop<Qualifier>;
            }
        }
        interface Validation<ValueDef extends Atom.Def.Constraint, out Qualifier extends Atom.Qualifier.Constraint> {
            errors: Field.Error[];
            useErrors: Field.Errors.Use.Prop<Qualifier>;
            valid: boolean;
            useValid: Field.Valid.Use.Prop<Qualifier>;
            addError: Field.AddError.Prop;
            clearErrors(): void;
        }
    }
    type Def<ReadValue, WriteValue = ReadValue> = Atom.Def<ReadValue, WriteValue>;
    namespace Value {
        namespace Use {
            type IncludeMeta<Props extends Use.Props | undefined> = undefined extends Props ? false : Props extends Use.Props ? Props["meta"] extends true ? true : Props["meta"] extends false ? false : Props["valid"] extends true ? true : Props["dirty"] extends true ? true : false : false;
            interface Props extends Meta.Props {
                meta?: boolean | undefined;
            }
        }
    }
    namespace Dirty {
        namespace Use {
            type Prop<Qualifier extends Atom.Qualifier.Constraint> = Atom.Qualifier.Ref.DisableFor<Qualifier, Fn>;
            interface Fn {
                <Enable extends boolean | undefined = undefined>(enable?: Enable): Atom.Hooks.Result<Enable, boolean>;
            }
        }
    }
    namespace Commit {
        type Prop<Qualifier extends Atom.Qualifier.Constraint> = Atom.Qualifier.Ref.DisableFor<Qualifier, Fn>;
        interface Fn {
            (): void;
        }
    }
    namespace Reset {
        type Prop<Qualifier extends Atom.Qualifier.Constraint> = Atom.Qualifier.Ref.DisableFor<Qualifier, Fn>;
        interface Fn {
            (): void;
        }
    }
    type Parent<ParentValue, Key extends keyof ParentValue> = Atom.Parent.Interface<ParentValue, Key>;
    type Unwatch = Atom.Unwatch;
    type Decomposed<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.Decompose.Result<"field", "exact", Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent>;
    type DecomposedVariant<Value, Variant extends Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Decomposed<Value, Qualifier, Parent> & {
        value: Variant;
    };
    type DecomposedNullish<Value, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.DecomposeNullish.Result<"field", "exact", Atom.Def<Value>, Atom.Qualifier.Internalize<Qualifier>, Parent>;
    type Discriminated<Value, Discriminator extends Atom.Discriminate.Discriminator<Atom.Def<Value>>, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Atom.Discriminate.Result<"field", "exact", Atom.Def<Value>, Discriminator, Atom.Qualifier.Internalize<Qualifier>, Parent>;
    type DiscriminatedVariant<Value, Discriminator extends Atom.Discriminate.Discriminator<Atom.Def<Value>>, Variant extends Discriminator extends keyof Value ? Value[Discriminator] : never, Qualifier extends Atom.Qualifier.External.Constraint = Atom.Qualifier.External.Default, Parent extends Atom.Parent.Constraint<Atom.Def<Value>> = Atom.Parent.Default> = Discriminated<Value, Discriminator, Qualifier, Parent> & {
        discriminator: Variant;
    };
    type Proxy<SourceValue = any> = Atom.Proxy.Qualifier<Atom.Def<SourceValue>>;
    type Meta<Props extends Meta.Props | undefined> = Props extends Meta.Props ? {
        valid: Meta.Enable<Props["valid"], boolean>;
        errors: Meta.Enable<Props["errors"], Error[]>;
        dirty: Meta.Enable<Props["dirty"], boolean>;
    } : {
        valid: boolean;
        errors: Error[];
        dirty: boolean;
    };
    namespace Meta {
        interface Props {
            valid?: boolean | undefined;
            errors?: boolean | undefined;
            dirty?: boolean | undefined;
        }
        type Enable<Enable, Value> = Enable extends true ? Value : Enable extends false ? undefined : Enable extends boolean ? Value | undefined : Enable extends undefined ? undefined : never;
    }
    namespace Control {
        interface Props<Element extends HTMLElement> {
            ref?: React.RefCallback<Element> | React.RefObject<Element | null> | undefined;
            onBlur?: FocusEventHandler<Element> | undefined;
        }
        interface Registration<Element extends HTMLElement> {
            name: string;
            ref: React.RefCallback<Element>;
            onBlur: FocusEventHandler<Element>;
        }
    }
    namespace Component {
        type Props<Value, MetaEnable extends boolean | undefined = undefined, DirtyEnable extends boolean = false, ErrorsEnable extends boolean = false, ValidEnable extends boolean = false> = {
            field: Field<Value>;
            render: Render<Value, MetaEnable extends true ? undefined : MetaEnable extends false ? {
                valid: false;
                errors: false;
                dirty: false;
            } : {
                valid: ValidEnable;
                errors: ErrorsEnable;
                dirty: DirtyEnable;
            }>;
            meta?: MetaEnable;
            dirty?: DirtyEnable;
            errors?: ErrorsEnable;
            valid?: ValidEnable;
        };
        type Render<Value, MetaProps extends Meta.Props | undefined> = (input: Input<Value>, meta: Meta<MetaProps>) => ReactNode;
    }
    type Input<Value> = {
        name: string;
        value: Value;
        onChange: Input.OnChange<Value>;
        onBlur: FocusEventHandler<Element>;
    };
    namespace Input {
        type OnChange<Value> = (value: Value) => void;
    }
    interface Error {
        type?: string | undefined;
        message: string;
    }
    namespace Error {
        type Type = Error | string;
    }
    namespace Valid {
        namespace Use {
            type Prop<Qualifier extends Atom.Qualifier.Constraint> = Atom.Qualifier.Ref.DisableFor<Qualifier, Fn>;
            interface Fn {
                <Enable extends boolean | undefined = undefined>(enable?: Enable): Atom.Hooks.Result<Enable, boolean>;
            }
        }
    }
    interface Validator<Value> {
        (field: Field.Immutable<Value, "ref">): Promise<void> | void;
    }
    namespace Validate {
        type Prop<ValueDef extends Atom.Def.Constraint, Qualifier extends Atom.Qualifier.Constraint> = Atom.Qualifier.Ref.DisableFor<Qualifier, Fn<ValueDef["read"]>>;
        interface Fn<Value> {
            (validator: Field.Validator<Value>): Promise<void>;
        }
    }
    namespace Errors {
        namespace Use {
            type Prop<Qualifier extends Atom.Qualifier.Constraint> = Atom.Qualifier.Ref.DisableFor<Qualifier, Fn>;
            interface Fn {
                <Enable extends boolean | undefined = undefined>(enable?: Enable): Atom.Hooks.Result<Enable, Field.Error[]>;
            }
        }
    }
    namespace AddError {
        type Prop = Fn;
        interface Fn {
            (error: Error.Type): void;
        }
    }
}
export {};
//# sourceMappingURL=definition.d.ts.map