@rolster/react-forms 18.8.2 → 18.9.0

package/dist/esm/form-array/form-array-group.js

@@ -1,55 +1,55 @@
-import { createFormGroupOptions } from '@rolster/forms/arguments';
-import { controlsAllChecked, controlsPartialChecked, controlsToValue, groupIsValid } from '@rolster/forms/helpers';
-import { v4 as uuid } from 'uuid';
-export class RolsterArrayGroup {
-    constructor(options) {
-        const { controls, resource, uuid, validators } = options;
-        this.uuid = uuid;
-        this.controls = controls;
-        this.validators = validators;
-        this.resource = resource;
-        this.errors = validators ? groupIsValid({ controls, validators }) : [];
-        this.error = this.errors[0];
-        this.valid =
-            this.errors.length === 0 && controlsAllChecked(controls, 'valid');
-        this.invalid = !this.valid;
-        this.dirty = controlsPartialChecked(controls, 'dirty');
-        this.dirtyAll = controlsAllChecked(controls, 'dirty');
-        this.touched = controlsPartialChecked(controls, 'touched');
-        this.touchedAll = controlsAllChecked(controls, 'touched');
-        this.untouched = !this.touched;
-        this.untouchedAll = !this.touchedAll;
-        this.pristine = !this.dirty;
-        this.pristineAll = !this.dirtyAll;
-        this.wrong = this.touched && this.invalid;
-        this.value = controlsToValue(controls);
-        const subscriber = (options) => {
-            this.refresh({
-                controls: Object.entries(this.controls).reduce((controls, [key, control]) => {
-                    controls[key] =
-                        control.uuid === options.uuid ? control.clone(options) : control;
-                    return controls;
-                }, {})
-            });
-        };
-        Object.values(controls).forEach((control) => {
-            control.subscribe(subscriber);
-        });
-    }
-    setValidators(validators) {
-        this.refresh({ validators });
-    }
-    subscribe(subscriber) {
-        this.subscriber = subscriber;
-    }
-    refresh(changes) {
-        this.subscriber && this.subscriber({ ...this, ...changes });
-    }
-}
-export function formArrayGroup(options, validators) {
-    return new RolsterArrayGroup({
-        ...createFormGroupOptions(options, validators),
-        uuid: uuid()
-    });
-}
+import { createFormGroupOptions } from '@rolster/forms/arguments';
+import { controlsAllChecked, controlsPartialChecked, controlsToValue, groupIsValid } from '@rolster/forms/helpers';
+import { v4 as uuid } from 'uuid';
+export class RolsterArrayGroup {
+    constructor(options) {
+        const { controls, resource, uuid, validators } = options;
+        this.uuid = uuid;
+        this.controls = controls;
+        this.validators = validators;
+        this.resource = resource;
+        this.errors = validators ? groupIsValid({ controls, validators }) : [];
+        this.error = this.errors[0];
+        this.valid =
+            this.errors.length === 0 && controlsAllChecked(controls, 'valid');
+        this.invalid = !this.valid;
+        this.dirty = controlsPartialChecked(controls, 'dirty');
+        this.dirtyAll = controlsAllChecked(controls, 'dirty');
+        this.touched = controlsPartialChecked(controls, 'touched');
+        this.touchedAll = controlsAllChecked(controls, 'touched');
+        this.untouched = !this.touched;
+        this.untouchedAll = !this.touchedAll;
+        this.pristine = !this.dirty;
+        this.pristineAll = !this.dirtyAll;
+        this.wrong = this.touched && this.invalid;
+        this.value = controlsToValue(controls);
+        const subscriber = (options) => {
+            this.refresh({
+                controls: Object.entries(this.controls).reduce((controls, [key, control]) => {
+                    controls[key] =
+                        control.uuid === options.uuid ? control.clone(options) : control;
+                    return controls;
+                }, {})
+            });
+        };
+        Object.values(controls).forEach((control) => {
+            control.subscribe(subscriber);
+        });
+    }
+    setValidators(validators) {
+        this.refresh({ validators });
+    }
+    subscribe(subscriber) {
+        this.subscriber = subscriber;
+    }
+    refresh(changes) {
+        this.subscriber && this.subscriber({ ...this, ...changes });
+    }
+}
+export function formArrayGroup(options, validators) {
+    return new RolsterArrayGroup({
+        ...createFormGroupOptions(options, validators),
+        uuid: uuid()
+    });
+}
 //# sourceMappingURL=form-array-group.js.map

package/dist/esm/form-array/form-array-list.d.ts

@@ -1,26 +1,26 @@
-import { ArrayControlsValue, ArrayListValueToControls } from '@rolster/forms';
-import { ValidatorFn } from '@rolster/validators';
-import { ReactArrayControls, ReactArrayList, ReactArrayListOptions } from '../types';
-import { RolsterReactArrayControl } from './form-array-control';
-type RolsterListOptions<C extends ReactArrayControls = ReactArrayControls> = Omit<ReactArrayListOptions<C>, 'value'>;
-export declare class RolsterArrayList<E extends HTMLElement = HTMLElement, C extends ReactArrayControls = ReactArrayControls> extends RolsterReactArrayControl<E, ArrayControlsValue<C>[]> implements ReactArrayList<C> {
-    readonly controls: C[];
-    readonly invalid: boolean;
-    readonly valid: boolean;
-    readonly wrong: boolean;
-    protected valueToControls: ArrayListValueToControls<C>;
-    constructor(options: RolsterListOptions<C>);
-    setValue(value: ArrayControlsValue<C>[]): void;
-    clone(options: ReactArrayListOptions<C>): RolsterArrayList<E, C>;
-    push(controls: C): void;
-    remove(controls: C): void;
-    protected refresh(changes: Partial<ReactArrayListOptions<C>>): void;
-    private subscribeControls;
-}
-interface ReactListOptions<C extends ReactArrayControls = ReactArrayControls> {
-    touched?: boolean;
-    validators?: ValidatorFn<ArrayControlsValue<C>[] | undefined>[];
-    value?: ArrayControlsValue<C>[] | undefined;
-}
-export declare function formArrayList<C extends ReactArrayControls = ReactArrayControls>(valueToControls: ArrayListValueToControls<C>, options?: ReactListOptions<C>): ReactArrayList<C>;
-export {};
+import { ArrayControlsValue, ArrayListValueToControls } from '@rolster/forms';
+import { ValidatorFn } from '@rolster/validators';
+import { ReactArrayControls, ReactArrayList, ReactArrayListOptions } from '../types';
+import { RolsterReactArrayControl } from './form-array-control';
+type RolsterListOptions<C extends ReactArrayControls = ReactArrayControls> = Omit<ReactArrayListOptions<C>, 'value'>;
+export declare class RolsterArrayList<E extends HTMLElement = HTMLElement, C extends ReactArrayControls = ReactArrayControls> extends RolsterReactArrayControl<E, ArrayControlsValue<C>[]> implements ReactArrayList<C> {
+    readonly controls: C[];
+    readonly invalid: boolean;
+    readonly valid: boolean;
+    readonly wrong: boolean;
+    protected valueToControls: ArrayListValueToControls<C>;
+    constructor(options: RolsterListOptions<C>);
+    setValue(value: ArrayControlsValue<C>[]): void;
+    clone(options: ReactArrayListOptions<C>): RolsterArrayList<E, C>;
+    push(controls: C): void;
+    remove(controls: C): void;
+    protected refresh(changes: Partial<ReactArrayListOptions<C>>): void;
+    private subscribeControls;
+}
+interface ReactListOptions<C extends ReactArrayControls = ReactArrayControls> {
+    touched?: boolean;
+    validators?: ValidatorFn<ArrayControlsValue<C>[] | undefined>[];
+    value?: ArrayControlsValue<C>[] | undefined;
+}
+export declare function formArrayList<C extends ReactArrayControls = ReactArrayControls>(valueToControls: ArrayListValueToControls<C>, options?: ReactListOptions<C>): ReactArrayList<C>;
+export {};

package/dist/esm/form-array/form-array-list.js

@@ -1,67 +1,67 @@
-import { controlsAllChecked, controlsToValue } from '@rolster/forms/helpers';
-import { v4 as uuid } from 'uuid';
-import { RolsterReactArrayControl } from './form-array-control';
-export class RolsterArrayList extends RolsterReactArrayControl {
-    constructor(options) {
-        const value = options.controls.map((controls) => controlsToValue(controls));
-        super({ ...options, value });
-        this.valueToControls = options.valueToControls;
-        this.controls = options.controls;
-        this.valid =
-            this.errors.length === 0 &&
-                this.controls.reduce((valid, controls) => valid && controlsAllChecked(controls, 'valid'), true);
-        this.invalid = !this.valid;
-        this.wrong = this.touched && this.invalid;
-        options.controls.forEach((controls) => {
-            this.subscribeControls(controls);
-        });
-    }
-    setValue(value) {
-        this.refresh({
-            controls: value.map((value) => this.valueToControls(value))
-        });
-    }
-    clone(options) {
-        return new RolsterArrayList(options);
-    }
-    push(controls) {
-        this.refresh({
-            controls: [...this.controls, controls]
-        });
-    }
-    remove(controls) {
-        this.refresh({
-            controls: this.controls.filter((currentControls) => currentControls !== controls)
-        });
-    }
-    refresh(changes) {
-        super.refresh(changes);
-    }
-    subscribeControls(newControls) {
-        Object.values(newControls).forEach((control) => {
-            control.subscribe((options) => {
-                const controls = this.controls.map((currentControls) => currentControls !== newControls
-                    ? currentControls
-                    : Object.entries(newControls).reduce((controls, [key, control]) => {
-                        controls[key] =
-                            control.uuid === options.uuid
-                                ? control.clone(options)
-                                : control;
-                        return controls;
-                    }, {}));
-                this.refresh({ controls });
-            });
-        });
-    }
-}
-export function formArrayList(valueToControls, options) {
-    const value = options?.value || [];
-    return new RolsterArrayList({
-        ...options,
-        valueToControls,
-        controls: value.map((value) => valueToControls(value)),
-        initialValue: value,
-        uuid: uuid()
-    });
-}
+import { controlsAllChecked, controlsToValue } from '@rolster/forms/helpers';
+import { v4 as uuid } from 'uuid';
+import { RolsterReactArrayControl } from './form-array-control';
+export class RolsterArrayList extends RolsterReactArrayControl {
+    constructor(options) {
+        const value = options.controls.map((controls) => controlsToValue(controls));
+        super({ ...options, value });
+        this.valueToControls = options.valueToControls;
+        this.controls = options.controls;
+        this.valid =
+            this.errors.length === 0 &&
+                this.controls.reduce((valid, controls) => valid && controlsAllChecked(controls, 'valid'), true);
+        this.invalid = !this.valid;
+        this.wrong = this.touched && this.invalid;
+        options.controls.forEach((controls) => {
+            this.subscribeControls(controls);
+        });
+    }
+    setValue(value) {
+        this.refresh({
+            controls: value.map((value) => this.valueToControls(value))
+        });
+    }
+    clone(options) {
+        return new RolsterArrayList(options);
+    }
+    push(controls) {
+        this.refresh({
+            controls: [...this.controls, controls]
+        });
+    }
+    remove(controls) {
+        this.refresh({
+            controls: this.controls.filter((currentControls) => currentControls !== controls)
+        });
+    }
+    refresh(changes) {
+        super.refresh(changes);
+    }
+    subscribeControls(newControls) {
+        Object.values(newControls).forEach((control) => {
+            control.subscribe((options) => {
+                const controls = this.controls.map((currentControls) => currentControls !== newControls
+                    ? currentControls
+                    : Object.entries(newControls).reduce((controls, [key, control]) => {
+                        controls[key] =
+                            control.uuid === options.uuid
+                                ? control.clone(options)
+                                : control;
+                        return controls;
+                    }, {}));
+                this.refresh({ controls });
+            });
+        });
+    }
+}
+export function formArrayList(valueToControls, options) {
+    const value = options?.value || [];
+    return new RolsterArrayList({
+        ...options,
+        valueToControls,
+        controls: value.map((value) => valueToControls(value)),
+        initialValue: value,
+        uuid: uuid()
+    });
+}
 //# sourceMappingURL=form-array-list.js.map

package/dist/esm/form-array/form-array.d.ts

@@ -1,5 +1,5 @@
-import { FormArrayOptions, ValidatorArrayFn } from '@rolster/forms';
-import { ReactArrayControls, ReactArrayGroup, ReactFormArray } from '../types';
-export declare function useFormArray<C extends ReactArrayControls, R = any, G extends ReactArrayGroup<C, R> = ReactArrayGroup<C, R>>(): ReactFormArray<C, R, G>;
-export declare function useFormArray<C extends ReactArrayControls, R = any, G extends ReactArrayGroup<C, R> = ReactArrayGroup<C, R>>(options: FormArrayOptions<C, R, G>): ReactFormArray<C, R, G>;
-export declare function useFormArray<C extends ReactArrayControls, R = any, G extends ReactArrayGroup<C, R> = ReactArrayGroup<C, R>>(groups: ReactArrayGroup<C, R>[], validators?: ValidatorArrayFn<C, R>[]): ReactFormArray<C, R, G>;
+import { FormArrayOptions, ValidatorArrayFn } from '@rolster/forms';
+import { ReactArrayControls, ReactArrayGroup, ReactFormArray } from '../types';
+export declare function useFormArray<C extends ReactArrayControls, R = any, G extends ReactArrayGroup<C, R> = ReactArrayGroup<C, R>>(): ReactFormArray<C, R, G>;
+export declare function useFormArray<C extends ReactArrayControls, R = any, G extends ReactArrayGroup<C, R> = ReactArrayGroup<C, R>>(options: FormArrayOptions<C, R, G>): ReactFormArray<C, R, G>;
+export declare function useFormArray<C extends ReactArrayControls, R = any, G extends ReactArrayGroup<C, R> = ReactArrayGroup<C, R>>(groups: ReactArrayGroup<C, R>[], validators?: ValidatorArrayFn<C, R>[]): ReactFormArray<C, R, G>;

package/dist/esm/form-array/form-array.js

@@ -1,101 +1,101 @@
-import { createFormArrayOptions } from '@rolster/forms/arguments';
-import { arrayIsValid, controlsToValue, groupAllChecked, groupPartialChecked, hasError as rolsterHasError, someErrors as rolsterSomeErrors } from '@rolster/forms/helpers';
-import { useEffect, useRef, useState } from 'react';
-import { RolsterArrayGroup } from './form-array-group';
-export function useFormArray(options, arrayValidators) {
-    const arrayOptions = createFormArrayOptions(options, arrayValidators);
-    const groups = arrayOptions.groups || [];
-    const currentState = useRef(groups);
-    const [state, setState] = useState({
-        controls: groups.map(({ controls }) => controls),
-        disabled: false,
-        groups,
-        value: groups.map(({ controls }) => controlsToValue(controls)),
-        validators: arrayOptions.validators
-    });
-    const errors = state.validators
-        ? arrayIsValid({ groups, validators: state.validators })
-        : [];
-    const error = errors[0];
-    const valid = errors.length === 0 && groupAllChecked(state.groups, 'valid');
-    const dirty = groupPartialChecked(state.groups, 'dirty');
-    const dirtyAll = groupAllChecked(state.groups, 'dirty');
-    const touched = groupPartialChecked(state.groups, 'touched');
-    const touchedAll = groupAllChecked(state.groups, 'touched');
-    useEffect(() => {
-        const subscriber = (options) => {
-            setGroups(state.groups.map((group) => group.uuid === options.uuid
-                ? new RolsterArrayGroup(options)
-                : group));
-        };
-        state.groups.forEach((group) => {
-            group.subscribe(subscriber);
-        });
-    }, [state.groups]);
-    function disable() {
-        setState((state) => ({ ...state, disabled: true }));
-    }
-    function enable() {
-        setState((state) => ({ ...state, disabled: false }));
-    }
-    function setGroups(groups) {
-        setState((currentState) => ({
-            ...currentState,
-            groups,
-            controls: groups.map(({ controls }) => controls),
-            value: groups.map(({ controls }) => controlsToValue(controls))
-        }));
-    }
-    function push(group) {
-        setGroups([...state.groups, group]);
-    }
-    function merge(groups) {
-        setGroups([...state.groups, ...groups]);
-    }
-    function set(groups) {
-        setGroups(groups);
-    }
-    function remove({ uuid }) {
-        setGroups(state.groups.filter((group) => group.uuid !== uuid));
-    }
-    function hasError(key) {
-        return rolsterHasError(errors, key);
-    }
-    function someErrors(keys) {
-        return rolsterSomeErrors(errors, keys);
-    }
-    function reset() {
-        setGroups(currentState.current);
-    }
-    function setValidators(validators) {
-        setState((state) => ({ ...state, validators }));
-    }
-    return {
-        ...state,
-        dirty,
-        dirtyAll,
-        disable,
-        enable,
-        enabled: !state.disabled,
-        error,
-        errors,
-        hasError,
-        invalid: !valid,
-        merge,
-        pristine: !dirty,
-        pristineAll: !dirtyAll,
-        push,
-        remove,
-        reset,
-        set,
-        setValidators,
-        someErrors,
-        touched,
-        touchedAll,
-        untouched: !touched,
-        untouchedAll: !touchedAll,
-        valid,
-        wrong: touched && !valid
-    };
-}
+import { createFormArrayOptions } from '@rolster/forms/arguments';
+import { arrayIsValid, controlsToValue, groupAllChecked, groupPartialChecked, hasError as rolsterHasError, someErrors as rolsterSomeErrors } from '@rolster/forms/helpers';
+import { useEffect, useRef, useState } from 'react';
+import { RolsterArrayGroup } from './form-array-group';
+export function useFormArray(options, arrayValidators) {
+    const arrayOptions = createFormArrayOptions(options, arrayValidators);
+    const groups = arrayOptions.groups || [];
+    const currentState = useRef(groups);
+    const [state, setState] = useState({
+        controls: groups.map(({ controls }) => controls),
+        disabled: false,
+        groups,
+        value: groups.map(({ controls }) => controlsToValue(controls)),
+        validators: arrayOptions.validators
+    });
+    const errors = state.validators
+        ? arrayIsValid({ groups, validators: state.validators })
+        : [];
+    const error = errors[0];
+    const valid = errors.length === 0 && groupAllChecked(state.groups, 'valid');
+    const dirty = groupPartialChecked(state.groups, 'dirty');
+    const dirtyAll = groupAllChecked(state.groups, 'dirty');
+    const touched = groupPartialChecked(state.groups, 'touched');
+    const touchedAll = groupAllChecked(state.groups, 'touched');
+    useEffect(() => {
+        const subscriber = (options) => {
+            setGroups(state.groups.map((group) => group.uuid === options.uuid
+                ? new RolsterArrayGroup(options)
+                : group));
+        };
+        state.groups.forEach((group) => {
+            group.subscribe(subscriber);
+        });
+    }, [state.groups]);
+    function disable() {
+        setState((state) => ({ ...state, disabled: true }));
+    }
+    function enable() {
+        setState((state) => ({ ...state, disabled: false }));
+    }
+    function setGroups(groups) {
+        setState((currentState) => ({
+            ...currentState,
+            groups,
+            controls: groups.map(({ controls }) => controls),
+            value: groups.map(({ controls }) => controlsToValue(controls))
+        }));
+    }
+    function push(group) {
+        setGroups([...state.groups, group]);
+    }
+    function merge(groups) {
+        setGroups([...state.groups, ...groups]);
+    }
+    function set(groups) {
+        setGroups(groups);
+    }
+    function remove({ uuid }) {
+        setGroups(state.groups.filter((group) => group.uuid !== uuid));
+    }
+    function hasError(key) {
+        return rolsterHasError(errors, key);
+    }
+    function someErrors(keys) {
+        return rolsterSomeErrors(errors, keys);
+    }
+    function reset() {
+        setGroups(currentState.current);
+    }
+    function setValidators(validators) {
+        setState((state) => ({ ...state, validators }));
+    }
+    return {
+        ...state,
+        dirty,
+        dirtyAll,
+        disable,
+        enable,
+        enabled: !state.disabled,
+        error,
+        errors,
+        hasError,
+        invalid: !valid,
+        merge,
+        pristine: !dirty,
+        pristineAll: !dirtyAll,
+        push,
+        remove,
+        reset,
+        set,
+        setValidators,
+        someErrors,
+        touched,
+        touchedAll,
+        untouched: !touched,
+        untouchedAll: !touchedAll,
+        valid,
+        wrong: touched && !valid
+    };
+}
 //# sourceMappingURL=form-array.js.map

package/dist/esm/form-array/index.d.ts

@@ -1,4 +1,4 @@
-export { formArrayControl, inputArrayControl, reactArrayControl } from './form-array-control';
-export { formArrayGroup } from './form-array-group';
-export { formArrayList } from './form-array-list';
-export { useFormArray } from './form-array';
+export { formArrayControl, inputArrayControl, reactArrayControl } from './form-array-control';
+export { formArrayGroup } from './form-array-group';
+export { formArrayList } from './form-array-list';
+export { useFormArray } from './form-array';

package/dist/esm/form-array/index.js

@@ -1,5 +1,5 @@
-export { formArrayControl, inputArrayControl, reactArrayControl } from './form-array-control';
-export { formArrayGroup } from './form-array-group';
-export { formArrayList } from './form-array-list';
-export { useFormArray } from './form-array';
+export { formArrayControl, inputArrayControl, reactArrayControl } from './form-array-control';
+export { formArrayGroup } from './form-array-group';
+export { formArrayList } from './form-array-list';
+export { useFormArray } from './form-array';
 //# sourceMappingURL=index.js.map

package/dist/esm/form-control.d.ts

@@ -1,27 +1,27 @@
-import { FormControlOptions } from '@rolster/forms';
-import { ValidatorFn } from '@rolster/validators';
-import { ReactFormControl, ReactHtmlControl, ReactInputControl } from './types';
-interface ReactControlOptions<T = any> extends FormControlOptions<T> {
-    touched?: boolean;
-}
-type ReactValueOptions<T> = Omit<ReactControlOptions<T>, 'validators'>;
-type ReactValidatorsOptions<T> = Omit<ReactControlOptions<T>, 'value'>;
-export declare function useReactControl<E extends HTMLElement, T>(): ReactFormControl<E, T | undefined>;
-export declare function useReactControl<E extends HTMLElement, T>(options: ReactValueOptions<T>): ReactFormControl<E, T>;
-export declare function useReactControl<E extends HTMLElement, T>(options: ReactValidatorsOptions<T>): ReactFormControl<E, T | undefined>;
-export declare function useReactControl<E extends HTMLElement, T>(options: ReactControlOptions<T>): ReactFormControl<E, T>;
-export declare function useReactControl<E extends HTMLElement, T>(value: undefined, validators?: ValidatorFn<T>[]): ReactFormControl<E, T | undefined>;
-export declare function useReactControl<E extends HTMLElement, T>(value: T, validators?: ValidatorFn<T>[]): ReactFormControl<E, T>;
-export declare function useFormControl<T>(): ReactHtmlControl<T | undefined>;
-export declare function useFormControl<T>(options: ReactValueOptions<T>): ReactHtmlControl<T>;
-export declare function useFormControl<T>(options: ReactValidatorsOptions<T>): ReactHtmlControl<T | undefined>;
-export declare function useFormControl<T>(options: ReactControlOptions<T>): ReactHtmlControl<T>;
-export declare function useFormControl<T>(value: undefined, validators?: ValidatorFn<T>[]): ReactHtmlControl<T | undefined>;
-export declare function useFormControl<T>(value: T, validators?: ValidatorFn<T>[]): ReactHtmlControl<T>;
-export declare function useInputControl<T>(): ReactInputControl<T | undefined>;
-export declare function useInputControl<T>(options: ReactValueOptions<T>): ReactInputControl<T>;
-export declare function useInputControl<T>(options: ReactValidatorsOptions<T>): ReactInputControl<T | undefined>;
-export declare function useInputControl<T>(options: ReactControlOptions<T>): ReactInputControl<T>;
-export declare function useInputControl<T>(value: undefined, validators?: ValidatorFn<T>[]): ReactInputControl<T | undefined>;
-export declare function useInputControl<T>(value: T, validators?: ValidatorFn<T>[]): ReactInputControl<T>;
-export {};
+import { FormControlOptions } from '@rolster/forms';
+import { ValidatorFn } from '@rolster/validators';
+import { ReactFormControl, ReactHtmlControl, ReactInputControl } from './types';
+interface ReactControlOptions<T = any> extends FormControlOptions<T> {
+    touched?: boolean;
+}
+type ReactValueOptions<T> = Omit<ReactControlOptions<T>, 'validators'>;
+type ReactValidatorsOptions<T> = Omit<ReactControlOptions<T>, 'value'>;
+export declare function useReactControl<E extends HTMLElement, T>(): ReactFormControl<E, T | undefined>;
+export declare function useReactControl<E extends HTMLElement, T>(options: ReactValueOptions<T>): ReactFormControl<E, T>;
+export declare function useReactControl<E extends HTMLElement, T>(options: ReactValidatorsOptions<T>): ReactFormControl<E, T | undefined>;
+export declare function useReactControl<E extends HTMLElement, T>(options: ReactControlOptions<T>): ReactFormControl<E, T>;
+export declare function useReactControl<E extends HTMLElement, T>(value: undefined, validators?: ValidatorFn<T>[]): ReactFormControl<E, T | undefined>;
+export declare function useReactControl<E extends HTMLElement, T>(value: T, validators?: ValidatorFn<T>[]): ReactFormControl<E, T>;
+export declare function useFormControl<T>(): ReactHtmlControl<T | undefined>;
+export declare function useFormControl<T>(options: ReactValueOptions<T>): ReactHtmlControl<T>;
+export declare function useFormControl<T>(options: ReactValidatorsOptions<T>): ReactHtmlControl<T | undefined>;
+export declare function useFormControl<T>(options: ReactControlOptions<T>): ReactHtmlControl<T>;
+export declare function useFormControl<T>(value: undefined, validators?: ValidatorFn<T>[]): ReactHtmlControl<T | undefined>;
+export declare function useFormControl<T>(value: T, validators?: ValidatorFn<T>[]): ReactHtmlControl<T>;
+export declare function useInputControl<T>(): ReactInputControl<T | undefined>;
+export declare function useInputControl<T>(options: ReactValueOptions<T>): ReactInputControl<T>;
+export declare function useInputControl<T>(options: ReactValidatorsOptions<T>): ReactInputControl<T | undefined>;
+export declare function useInputControl<T>(options: ReactControlOptions<T>): ReactInputControl<T>;
+export declare function useInputControl<T>(value: undefined, validators?: ValidatorFn<T>[]): ReactInputControl<T | undefined>;
+export declare function useInputControl<T>(value: T, validators?: ValidatorFn<T>[]): ReactInputControl<T>;
+export {};