@siberiacancode/reactuse 0.0.112 → 0.0.113

package/dist/types/hooks/useCounter/useCounter.d.ts

@@ -0,0 +1,51 @@
+import { Dispatch, SetStateAction } from 'react';
+/** The use counter options */
+export interface UseCounterOptions {
+    /** The max of count value */
+    max?: number;
+    /** The min of count value */
+    min?: number;
+}
+/** The use counter return type */
+export interface UseCounterReturn {
+    /** Function to set a specific value to the counter */
+    set: Dispatch<SetStateAction<number>>;
+    /** The current count value */
+    value: number;
+    /** Function to decrement the counter */
+    dec: (value?: number) => void;
+    /** Function to increment the counter */
+    inc: (value?: number) => void;
+    /** Function to reset the counter to its initial value. */
+    reset: () => void;
+}
+export interface UseCounter {
+    (initialValue?: number, options?: UseCounterOptions): UseCounterReturn;
+    (options: UseCounterOptions & {
+        initialValue?: number;
+    }, initialValue?: never): UseCounterReturn;
+}
+/**
+ * @name useCounter
+ * @description - Hook that manages a counter
+ * @category Utilities
+ *
+ * @overload
+ * @param {number} [initialValue=0] The initial number value
+ * @param {number} [options.min=Number.NEGATIVE_INFINITY] The min of count value
+ * @param {number} [options.max=Number.POSITIVE_INFINITY] The max of count value
+ * @returns {UseCounterReturn} An object containing the current count and functions to interact with the counter
+
+ * @overload
+ * @param {number} [params.initialValue=0] The initial number value
+ * @param {number} [params.min=Number.NEGATIVE_INFINITY] The min of count value
+ * @param {number} [params.max=Number.POSITIVE_INFINITY] The max of count value
+ * @returns {UseCounterReturn} An object containing the current count and functions to interact with the counter
+ *
+ * @example
+ * const { count, dec, inc, reset, set } = useCounter(5);
+ *
+ * @example
+ * const { count, dec, inc, reset, set } = useCounter({ initialValue: 5, min: 0, max: 10 });
+ */
+export declare const useCounter: UseCounter;

package/dist/types/hooks/useCssVar/useCssVar.d.ts

@@ -0,0 +1,38 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The css variable return type */
+export interface UseCssVarReturn {
+    /** The value of the CSS variable */
+    value: string;
+    /** Set the value of the CSS variable */
+    set: (value: string) => void;
+}
+export interface UseCssVar {
+    (key: string, initialValue?: string): UseCssVarReturn & {
+        ref: StateRef<Element>;
+    };
+    (target: HookTarget, key: string, initialValue?: string): UseCssVarReturn;
+}
+/**
+ * @name useCssVar
+ * @description - Hook that returns the value of a css variable
+ * @category Utilities
+ *
+ * @overload
+ * @param {string} key The CSS variable key
+ * @param {string} initialValue The initial value of the CSS variable
+ * @returns {UseCssVarReturn & { ref: StateRef<Element> }} The object containing the value of the CSS variable and ref
+ *
+ * @example
+ * const { ref, value, set } = useCssVar('--color', 'red');
+ *
+ * @overload
+ * @param {HookTarget} target The target element
+ * @param {string} key The CSS variable key
+ * @param {string} initialValue The initial value of the CSS variable
+ * @returns {UseCssVarReturn} The object containing the value of the CSS variable
+ *
+ * @example
+ * const { value, set } = useCssVar(ref, '--color', 'red');
+ */
+export declare const useCssVar: UseCssVar;

package/dist/types/hooks/useDebounceCallback/useDebounceCallback.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name useDebounceCallback
+ * @description - Hook that creates a debounced callback
+ * @category Utilities
+ *
+ * @template Params The type of the params
+ * @template Return The type of the return
+ * @param {(...args: Params) => Return} callback The callback function
+ * @param {number} delay The delay in milliseconds
+ * @returns {(...args: Params) => Return} The callback with debounce
+ *
+ * @example
+ * const debouncedCallback = useDebounceCallback(() => console.log('callback'), 500);
+ */
+export declare const useDebounceCallback: <Params extends unknown[], Return>(callback: (...args: Params) => Return, delay: number) => (...args: Params) => void;

package/dist/types/hooks/useDebounceValue/useDebounceValue.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @name useDebounceValue
+ * @description - Hook that creates a debounced value
+ * @category Utilities
+ *
+ * @template Value The type of the value
+ * @param {Value} value The value to be debounced
+ * @param {number} delay The delay in milliseconds
+ * @returns {Value} The debounced value
+ *
+ * @example
+ * const debouncedValue = useDebounceValue(value, 500);
+ */
+export declare const useDebounceValue: <Value>(value: Value, delay: number) => Value;

package/dist/types/hooks/useDefault/useDefault.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @name useDefault
+ * @description - Hook that returns the default value
+ * @category Utilities
+ *
+ * @template Value The type of the value
+ * @param {Value} initialValue The initial value
+ * @param {Value} defaultValue The default value
+ * @returns {[Value, (value: Value) => void]} An array containing the current value and a function to set the value
+ *
+ * @example
+ * const [value, setValue] = useDefault(initialValue, defaultValue);
+ */
+export declare const useDefault: <Value>(initialValue: (() => Value) | Value, defaultValue: Value) => readonly [Value, import('react').Dispatch<import('react').SetStateAction<Value | null | undefined>>];

package/dist/types/hooks/useDeviceMotion/useDeviceMotion.d.ts

@@ -0,0 +1,30 @@
+export interface UseDeviceMotionReturn {
+    acceleration: DeviceMotionEventAcceleration;
+    accelerationIncludingGravity: DeviceMotionEventAcceleration;
+    interval: DeviceMotionEvent['interval'];
+    rotationRate: DeviceMotionEventRotationRate;
+}
+export interface UseDeviceMotionParams {
+    /** The delay in milliseconds */
+    delay?: number;
+    /** Whether to enable the hook */
+    enabled?: boolean;
+    /** The callback function to be invoked */
+    callback?: (event: DeviceMotionEvent) => void;
+}
+/**
+ * @name useDeviceMotion
+ * @description - Hook that work with device motion
+ * @category Utilities
+ *
+ * @browserapi DeviceMotionEvent https://developer.mozilla.org/en-US/docs/Web/API/Window/DeviceMotionEvent
+ *
+ * @param {number} [delay=1000] The delay in milliseconds
+ * @param {(event: DeviceMotionEvent) => void} [callback] The callback function to be invoked
+ * @param {boolean} [enabled=true] Whether to enable the hook
+ * @returns {UseDeviceMotionReturn} The device motion data and interval
+ *
+ * @example
+ * const { interval, rotationRate, acceleration, accelerationIncludingGravity } = useDeviceMotion();
+ */
+export declare const useDeviceMotion: (params?: UseDeviceMotionParams) => UseDeviceMotionReturn;

package/dist/types/hooks/useDeviceOrientation/useDeviceOrientation.d.ts

@@ -0,0 +1,29 @@
+export interface UseDeviceOrientationValue {
+    /** The current absolute value */
+    absolute: boolean;
+    /** A number representing the motion of the device around the z axis, express in degrees with values ranging from 0 to 360 */
+    alpha: number | null;
+    /** A number representing the motion of the device around the x axis, express in degrees with values ranging from -180 to 180 */
+    beta: number | null;
+    /** A number representing the motion of the device around the y axis, express in degrees with values ranging from -90 to 90 */
+    gamma: number | null;
+}
+export interface UseDeviceOrientationReturn {
+    /** Whether the device orientation is supported */
+    supported: boolean;
+    /** The current device orientation value */
+    value: UseDeviceOrientationValue;
+}
+/**
+ * @name useDeviceOrientation
+ * @description - Hook that provides the current device orientation
+ * @category Sensors
+ *
+ * @browserapi DeviceOrientationEvent https://developer.mozilla.org/en-US/docs/Web/API/Window/DeviceOrientationEvent
+ *
+ * @returns {UseDeviceOrientationReturn} The current device orientation
+ *
+ * @example
+ * const { supported, value } = useDeviceOrientation();
+ */
+export declare const useDeviceOrientation: () => UseDeviceOrientationReturn;

package/dist/types/hooks/useDevicePixelRatio/useDevicePixelRatio.d.ts

@@ -0,0 +1,20 @@
+/** The use device pixel ratio return type */
+export interface UseDevicePixelRatioReturn {
+    /** The ratio of the resolution in physical pixels to the resolution in CSS pixels */
+    ratio: number;
+    /** Whether the device pixel ratio is supported*/
+    supported: boolean;
+}
+/**
+ * @name useDevicePixelRatio
+ * @description - Hook that returns the device's pixel ratio
+ * @category Utilities
+ *
+ * @browserapi window.devicePixelRatio https://developer.mozilla.org/en-US/docs/Web/API/Window/devicePixelRatio
+ *
+ * @returns {UseDevicePixelRatioReturn} The ratio and supported flag
+ *
+ * @example
+ * const { supported, ratio } = useDevicePixelRatio();
+ */
+export declare const useDevicePixelRatio: () => UseDevicePixelRatioReturn;

package/dist/types/hooks/useDidUpdate/useDidUpdate.d.ts

@@ -0,0 +1,13 @@
+import { DependencyList, EffectCallback } from 'react';
+/**
+ * @name useDidUpdate
+ * @description – Hook that triggers the effect callback on updates
+ * @category Lifecycle
+ *
+ * @param {EffectCallback} effect The effect callback
+ * @param {DependencyList} [deps] The dependencies list for the effect
+ *
+ * @example
+ * useDidUpdate(() => console.log("effect runs on updates"), [deps]);
+ */
+export declare const useDidUpdate: (effect: EffectCallback, deps?: DependencyList) => void;

package/dist/types/hooks/useDisclosure/useDisclosure.d.ts

@@ -0,0 +1,32 @@
+/** The use disclosure options type */
+export interface UseDisclosureOptions {
+    /** The callback function to be invoked on close */
+    onClose?: () => void;
+    /** The callback function to be invoked on open */
+    onOpen?: () => void;
+}
+/** The use disclosure return type */
+export interface UseDisclosureReturn {
+    /** The opened value */
+    opened: boolean;
+    /** Function to close the modal */
+    close: () => void;
+    /** Function to open the modal */
+    open: () => void;
+    /** Function to toggle the modal */
+    toggle: () => void;
+}
+/**
+ * @name useDisclosure
+ * @description - Hook that allows you to open and close a modal
+ * @category Utilities
+ *
+ * @param {boolean} [initialValue=false] The initial value of the component
+ * @param {() => void} [options.onOpen] The callback function to be invoked on open
+ * @param {() => void} [options.onClose] The callback function to be invoked on close
+ * @returns {UseDisclosureReturn} An object with the opened, open, close, and toggle properties
+ *
+ * @example
+ * const { opened, open, close, toggle } = useDisclosure();
+ */
+export declare const useDisclosure: (initialValue?: boolean, options?: UseDisclosureOptions) => UseDisclosureReturn;

package/dist/types/hooks/useDisplayMedia/useDisplayMedia.d.ts

@@ -0,0 +1,58 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The use display media return type */
+export interface UseDisplayMediaReturn {
+    /** Whether screen sharing is currently active */
+    sharing: boolean;
+    /** The media stream object */
+    stream: MediaStream | null;
+    /** Whether the display media API is supported */
+    supported: boolean;
+    /** Start screen sharing */
+    start: () => Promise<void>;
+    /** Stop screen sharing */
+    stop: () => void;
+}
+/** The use display media options type */
+export interface UseDisplayMediaOptions {
+    /** Whether to enable audio sharing */
+    audio?: boolean | MediaTrackConstraints;
+    /** Whether to start immediately */
+    immediately?: boolean;
+    /** Whether to enable video sharing */
+    video?: boolean | MediaTrackConstraints;
+}
+export interface UseDisplayMedia {
+    (target: HookTarget, options?: UseDisplayMediaOptions): UseDisplayMediaReturn;
+    <Target extends HTMLVideoElement>(options?: UseDisplayMediaOptions, target?: never): {
+        ref: StateRef<Target>;
+    } & UseDisplayMediaReturn;
+}
+/**
+ * @name useDisplayMedia
+ * @description - Hook that provides screen sharing functionality
+ * @category Browser
+ *
+ * @browserapi mediaDevices.getDisplayMedia https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getDisplayMedia
+ *
+ * @overload
+ * @param {HookTarget} target The target video element to display the media stream
+ * @param {boolean | MediaTrackConstraints} [options.audio] Whether to enable audio sharing
+ * @param {boolean} [options.immediately=false] Whether to start immediately
+ * @param {boolean | MediaTrackConstraints} [options.video] Whether to enable video sharing
+ * @returns {UseDisplayMediaReturn} Object containing stream, sharing status and control methods
+ *
+ * @example
+ * const { stream, sharing, start, stop } = useDisplayMedia(ref);
+ *
+ * @overload
+ * @template Target The target video element
+ * @param {boolean | MediaTrackConstraints} [options.audio] Whether to enable audio sharing
+ * @param {boolean} [options.immediately=false] Whether to start immediately
+ * @param {boolean | MediaTrackConstraints} [options.video] Whether to enable video sharing
+ * @returns {UseDisplayMediaReturn & { ref: StateRef<HTMLVideoElement> }} Object containing stream, sharing status, control methods and ref
+ *
+ * @example
+ * const { ref, stream, sharing, start, stop } = useDisplayMedia<HTMLVideoElement>();
+ */
+export declare const useDisplayMedia: UseDisplayMedia;

package/dist/types/hooks/useDocumentEvent/useDocumentEvent.d.ts

@@ -0,0 +1,16 @@
+import { UseEventListenerOptions } from '../useEventListener/useEventListener';
+/**
+ * @name useDocumentEvent
+ * @description - Hook attaches an event listener to the document object for the specified event
+ * @category Browser
+ *
+ * @template Event Key of document event map.
+ * @param {Event} event The event to listen for.
+ * @param {(event: DocumentEventMap[Event]) => void} listener The callback function to be executed when the event is triggered
+ * @param {UseEventListenerOptions} [options] The options for the event listener
+ * @returns {void}
+ *
+ * @example
+ * useDocumentEvent('click', () => console.log('clicked'));
+ */
+export declare const useDocumentEvent: <Event extends keyof DocumentEventMap>(event: Event, listener: (this: Document, event: DocumentEventMap[Event]) => any, options?: UseEventListenerOptions) => void;

package/dist/types/hooks/useDocumentTitle/useDocumentTitle.d.ts

@@ -0,0 +1,25 @@
+/** The use document title options type */
+export interface UseDocumentTitleOptions {
+    /** Restore the previous title on unmount */
+    restoreOnUnmount?: boolean;
+}
+/** The use document title return type */
+export interface UseDocumentTitleReturn {
+    /** The current title */
+    value: string;
+    /** Function to update the title */
+    set: (title: string) => void;
+}
+/**
+ * @name useDocumentTitle
+ * @description - Hook that manages the document title and allows updating it
+ * @category Browser
+ *
+ * @param {string} [initialValue] The initial title. If not provided, the current document title will be used
+ * @param {boolean} [options.restoreOnUnmount] Restore the previous title on unmount
+ * @returns {UseDocumentTitleReturn} An array containing the current title and a function to update the title
+ *
+ * @example
+ * const { value, set } = useDocumentTitle();
+ */
+export declare function useDocumentTitle(initialValue?: string, options?: UseDocumentTitleOptions): UseDocumentTitleReturn;

package/dist/types/hooks/useDocumentVisibility/useDocumentVisibility.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @name useDocumentVisibility
+ * @description – Hook that provides the current visibility state of the document
+ * @category Browser
+ *
+ * @returns {DocumentVisibilityState} The current visibility state of the document, which can be 'visible' or 'hidden'
+ *
+ * @example
+ * const visibilityState = useDocumentVisibility();
+ */
+export declare const useDocumentVisibility: () => DocumentVisibilityState;

package/dist/types/hooks/useElementSize/useElementSize.d.ts

@@ -0,0 +1,38 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The element size value type */
+export interface UseElementSizeValue {
+    /** The element's height */
+    height: number;
+    /** The element's width */
+    width: number;
+}
+/** The use element size return type */
+export interface UseElementSizeReturn {
+    value: UseElementSizeValue;
+}
+export interface UseElementSize {
+    (target: HookTarget): UseElementSizeReturn;
+    <Target extends Element>(target?: never): {
+        ref: StateRef<Target>;
+    } & UseElementSizeReturn;
+}
+/**
+ * @name useElementSize
+ * @description - Hook that observes and returns the width and height of element
+ * @category Elements
+ *
+ * @overload
+ * @param {HookTarget} target The target element to observe
+ * @returns {UseElementSizeReturn} An object containing the current width and height of the element
+ *
+ * @example
+ * const { value } = useElementSize(ref);
+ *
+ * @overload
+ * @returns { { ref: StateRef<Target> } & UseElementSizeReturn } An object containing the current width and height of the element
+ *
+ * @example
+ * const { ref, value } = useElementSize();
+ */
+export declare const useElementSize: UseElementSize;

package/dist/types/hooks/useEvent/useEvent.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @name useEvent
+ * @description - Hook that creates an event and returns a stable reference of it
+ * @category Browser
+ *
+ * @template Params The type of the params
+ * @template Return The type of the return
+ * @param {(...args: Params) => Return} callback The callback function
+ * @returns {(...args: Params) => Return} The callback
+ *
+ * @example
+ * const onClick = useEvent(() => console.log('clicked'));
+ */
+export declare const useEvent: <Params extends unknown[], Return>(callback: (...args: Params) => Return) => ((...args: Params) => Return);

package/dist/types/hooks/useEventListener/useEventListener.d.ts

@@ -0,0 +1,64 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The use event listener options */
+export type UseEventListenerOptions = boolean | AddEventListenerOptions;
+/** The use event listener return type */
+export type UseEventListenerReturn<Target extends Element> = StateRef<Target>;
+export interface UseEventListener {
+    <Event extends keyof WindowEventMap = keyof WindowEventMap>(target: Window, event: Event | Event[], listener: (this: Window, event: WindowEventMap[Event]) => void, options?: UseEventListenerOptions): void;
+    <Event extends keyof DocumentEventMap = keyof DocumentEventMap>(target: Document, event: Event | Event[], listener: (this: Document, event: DocumentEventMap[Event]) => void, options?: UseEventListenerOptions): void;
+    <Event extends keyof HTMLElementEventMap = keyof HTMLElementEventMap>(target: HookTarget, event: Event | Event[], listener: (this: Element, event: HTMLElementEventMap[Event]) => void, options?: UseEventListenerOptions): void;
+    <Target extends Element, Event extends keyof HTMLElementEventMap = keyof HTMLElementEventMap>(event: Event | Event[], listener: (this: Target, event: HTMLElementEventMap[Event]) => void, options?: UseEventListenerOptions, target?: never): UseEventListenerReturn<Target>;
+    <Target extends Element, Event extends keyof MediaQueryListEventMap = keyof MediaQueryListEventMap>(event: Event | Event[], listener: (this: Target, event: MediaQueryListEventMap[Event]) => void, options?: UseEventListenerOptions, target?: never): UseEventListenerReturn<Target>;
+}
+/**
+ * @name useEventListener
+ * @description - Hook that attaches an event listener to the specified target
+ * @category Browser
+ *
+ * @overload
+ * @template Event Key of window event map
+ * @param {Window} target The window object to attach the event listener to
+ * @param {Event | Event[]} event An array of event types to listen for
+ * @param {(this: Window, event: WindowEventMap[Event]) => void} handler The event handler function
+ * @param {UseEventListenerOptions} [options] Options for the event listener
+ * @returns {void}
+ *
+ * @example
+ * useEventListener(window, 'click', () => console.log('click'));
+ *
+ * @overload
+ * @template Event Key of window event map
+ * @param {Document} target The window object to attach the event listener to
+ * @param {Event | Event[]} event An array of event types to listen for
+ * @param {(this: Document, event: DocumentEventMap[Event]) => void} handler The event handler function
+ * @param {UseEventListenerOptions} [options] Options for the event listener
+ * @returns {void}
+ *
+ * @example
+ * useEventListener(document, 'click', () => console.log('click'));
+ *
+ * @overload
+ * @template Event Key of window event map
+ * @template Target The target element
+ * @param {HookTarget} target The target element to attach the event listener to
+ * @param {Event | Event[]} event An array of event types to listen for
+ * @param {(this: Target, event: HTMLElementEventMap[Event]) => void} handler The event handler function
+ * @param {UseEventListenerOptions} [options] Options for the event listener
+ * @returns {void}
+ *
+ * @example
+ * useEventListener(ref, 'click', () => console.log('click'));
+ *
+ * @overload
+ * @template Event Key of window event map
+ * @template Target The target element
+ * @param {Event | Event[]} event An array of event types to listen for
+ * @param {(this: Target, event: HTMLElementEventMap[Event] | MediaQueryListEventMap[Event]) => void} handler The event handler function
+ * @param {UseEventListenerOptions} [options] Options for the event listener
+ * @returns {UseEventListenerReturn<Target>} A reference to the target element
+ *
+ * @example
+ * const ref = useEventListener('click', () => console.log('click'));
+ */
+export declare const useEventListener: UseEventListener;

package/dist/types/hooks/useEyeDropper/useEyeDropper.d.ts

@@ -0,0 +1,40 @@
+export interface ColorSelectionOptions {
+    signal?: AbortSignal;
+}
+export interface ColorSelectionResult {
+    sRGBHex: string;
+}
+export interface EyeDropper {
+    open: (options?: ColorSelectionOptions) => Promise<ColorSelectionResult>;
+}
+export interface EyeDropperConstructor {
+    new (): EyeDropper;
+}
+declare global {
+    interface Window {
+        readonly EyeDropper?: EyeDropperConstructor | undefined;
+    }
+}
+/** The color selection return type */
+export interface UseEyeDropperReturn {
+    /** The eye dropper supported status */
+    supported: boolean;
+    /** The eye dropper value */
+    value?: string;
+    /** The eye dropper open method */
+    open: (colorSelectionOptions?: ColorSelectionOptions) => Promise<ColorSelectionResult>;
+}
+/**
+ * @name useEyeDropper
+ * @description - Hook that gives you access to the eye dropper
+ * @category Browser
+ *
+ * @browserapi EyeDropper https://developer.mozilla.org/en-US/docs/Web/API/EyeDropper
+ *
+ * @param {string} [initialValue=undefined] The initial value for the eye dropper
+ * @returns {UseEyeDropperReturn} An object containing the supported status, the value and the open method
+ *
+ * @example
+ * const { supported, value, open } = useEyeDropper();
+ */
+export declare const useEyeDropper: (initialValue?: string | undefined) => UseEyeDropperReturn;

package/dist/types/hooks/useFavicon/useFavicon.d.ts

@@ -0,0 +1,18 @@
+import { Dispatch, SetStateAction } from 'react';
+/** The use favicon return type */
+export type UseFaviconReturn = [string, Dispatch<SetStateAction<string>>];
+/**
+ * @name useFavicon
+ * @description - Hook that manages the favicon
+ * @category Browser
+ *
+ * @param {string} [initialFavicon] The initial favicon. If not provided, the current favicon will be used
+ * @returns {UseFaviconReturn} An array containing the current favicon and a function to update the favicon
+ *
+ * @example
+ * const { href, set } = useFavicon('https://www.google.com/favicon.ico');
+ */
+export declare const useFavicon: (initialHref?: string) => {
+    readonly href: string | undefined;
+    readonly set: (favicon: string) => void;
+};

package/dist/types/hooks/useField/useField.d.ts

@@ -0,0 +1,95 @@
+/** The use field params type */
+export interface UseFieldParams<Value> {
+    /** The auto focus */
+    autoFocus?: boolean;
+    /** The initial touched */
+    initialTouched?: boolean;
+    /** The initial value */
+    initialValue?: Value;
+    /** The validate on blur */
+    validateOnBlur?: boolean;
+    /** The validate on mount */
+    validateOnChange?: boolean;
+    /** The validate on mount */
+    validateOnMount?: boolean;
+}
+/** The use field register params type */
+export interface UseFieldRegisterParams {
+    /** The required validation */
+    required?: string;
+    /** The custom validation */
+    validate?: (value: string) => Promise<string | true>;
+    /** The min value validation */
+    max?: {
+        value: number;
+        message: string;
+    };
+    /** The max length validation */
+    maxLength?: {
+        value: number;
+        message: string;
+    };
+    /** The max value validation */
+    min?: {
+        value: number;
+        message: string;
+    };
+    /** The min length validation */
+    minLength?: {
+        value: number;
+        message: string;
+    };
+    /** The pattern validation */
+    pattern?: {
+        value: RegExp;
+        message: string;
+    };
+}
+/** The use field return type */
+export interface UseFieldReturn<Value> {
+    /** The dirty state */
+    dirty: boolean;
+    /** The error state */
+    error?: string;
+    /** The set error function */
+    touched: boolean;
+    /** The set error function */
+    clearError: () => void;
+    /** The focus function */
+    focus: () => void;
+    /** The get value function */
+    getValue: () => Value;
+    /** The register function */
+    register: (params?: UseFieldRegisterParams) => {
+        onBlur: () => void;
+        onChange: () => void;
+        ref: (node: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | null | undefined) => void;
+    };
+    /** The reset function */
+    reset: () => void;
+    /** The set error function */
+    setError: (error: string) => void;
+    /** The  set value function */
+    setValue: (value: Value) => void;
+    /** The watch function */
+    watch: () => Value;
+}
+/**
+ * @name useField
+ * @description - Hook to manage a form field
+ * @category Utilities
+ *
+ * @template Value The input value
+ * @template Type The input value type
+ * @param {Value} [params.initialValue] Initial value
+ * @param {boolean} [params.initialTouched=false] Initial touched state
+ * @param {boolean} [params.autoFocus=false] Auto focus
+ * @param {boolean} [params.validateOnChange=false] Validate on change
+ * @param {boolean} [params.validateOnBlur=false] Validate on blur
+ * @param {boolean} [params.validateOnMount=false] Validate on mount
+ * @returns {UseFieldReturn<Value>} An object containing input information
+ *
+ * @example
+ * const { register, getValue, setValue, reset, dirty, error, setError, clearError, touched, focus, watch } = useField();
+ */
+export declare const useField: <Value extends boolean | number | string = string, Type = Value extends string ? string : Value extends boolean ? boolean : number>(params?: UseFieldParams<Value>) => UseFieldReturn<Type>;