@siberiacancode/reactuse 0.0.111 → 0.0.113

package/dist/types/index.d.ts

@@ -1,4215 +1,2 @@
-import * as react from 'react';
-import { DependencyList, Dispatch, SetStateAction, EffectCallback, ComponentProps, useEffect, RefObject, MouseEventHandler, TouchEventHandler, MouseEvent as MouseEvent$1 } from 'react';
-import { HookTarget as HookTarget$1 } from '@/utils/helpers';
-
-/**
- * @name useActiveElement
- * @description - Hook that returns the active element
- * @category Elements
- *
- * @returns {ActiveElement | null} The active element
- *
- * @example
- * const activeElement = useActiveElement();
- */
-declare const useActiveElement: <ActiveElement extends HTMLElement>() => ActiveElement | null;
-
-interface UseAsyncReturn<Data> {
-    data?: Data;
-    error?: Error;
-    isError: boolean;
-    isLoading: boolean;
-}
-/**
- * @name useAsync
- * @description - Hook that provides the state of an async callback
- * @category Utilities
- *
- * @param {() => Promise<Data>} callback - The async callback
- * @param {DependencyList} deps - The dependencies of the callback
- * @returns {UseAsyncReturn<Data>} - The state of the async callback
- *
- * @example
- * const { data, isLoading, isError, error } = useAsync(() => fetch('url'), [deps]);
- */
-declare const useAsync: <Data>(callback: () => Promise<Data>, deps: DependencyList) => UseAsyncReturn<Data>;
-
-interface BatteryManager extends EventTarget {
-    charging: boolean;
-    chargingTime: number;
-    dischargingTime: number;
-    level: number;
-}
-declare global {
-    interface Navigator {
-        readonly getBattery: () => Promise<BatteryManager>;
-    }
-}
-/** The use battery value type */
-interface UseBatteryValue {
-    /** Is charging battery? */
-    charging: boolean;
-    /** Time until the battery is fully charged */
-    chargingTime: number;
-    /** Time until the battery is completely discharged */
-    dischargingTime: number;
-    /** Battery charge level from 0 to 1 */
-    level: number;
-    /** Is battery information loading? */
-    loading: boolean;
-}
-/** The use battery return type */
-interface UseBatteryStateReturn {
-    /** Whether the battery api is supported*/
-    supported: boolean;
-    /** The use battery value type  */
-    value: UseBatteryValue;
-}
-/**
- * @name useBattery
- * @description - Hook for getting information about battery status
- * @category Browser
- *
- * @browserapi navigator.getBattery https://developer.mozilla.org/en-US/docs/Web/API/Navigator/getBattery
- *
- * @returns {UseBatteryStateReturn} Object containing battery information & Battery API support
- *
- * @example
- * const { supported, loading, charging, chargingTime, dischargingTime, level } = useBattery();
- */
-declare const useBattery: () => UseBatteryStateReturn;
-
-/** The use bluetooth return type */
-interface UseBluetoothReturn {
-    /** Indicates if bluetooth device is currently connected */
-    connected: boolean;
-    /** Describe connected bluetooth device */
-    device?: BluetoothDevice;
-    /** The GATT server for connected bluetooth device */
-    server?: BluetoothRemoteGATTServer;
-    /** Whether the bluetooth is supported*/
-    supported: boolean;
-    /** Function to request bluetooth device from the user */
-    requestDevice: () => Promise<void>;
-}
-/** The use bluetooth options type */
-interface UseBluetoothOptions {
-    /** The options to request all bluetooth devices */
-    acceptAllDevices?: boolean;
-    /** Array of filters to apply when scanning bluetooth devices */
-    filters?: BluetoothLEScanFilter[];
-    /** Array of optional services that the application can use */
-    optionalServices?: BluetoothServiceUUID[];
-}
-/**
- * @name useBluetooth
- * @description - Hook for getting information about bluetooth
- * @category Browser
- *
- * @browserapi navigator.bluetooth https://developer.mozilla.org/en-US/docs/Web/API/Navigator/bluetooth
- *
- * @param {boolean} [options.acceptAllDevices=false] The options to request all Bluetooth devices
- * @param {Array<BluetoothLEScanFilter>} [options.filters] Array of filters to apply when scanning Bluetooth devices
- * @param {Array<BluetoothServiceUUID>} [options.optionalServices] Array of optional services that the application can use
- * @returns {UseBluetoothReturn} Object containing battery information & Battery API support
- *
- * @example
- * const { supported, connected, device, requestDevice, server } = useBluetooth(options);
- */
-declare const useBluetooth: (options?: UseBluetoothOptions) => UseBluetoothReturn;
-
-/** The use boolean return type */
-type UseBooleanReturn = [
-    /** The current boolean state value */
-    value: boolean,
-    /** Function to toggle the boolean state */
-    toggle: (value?: boolean) => void
-];
-/**
- * @name useBoolean
- * @description - Hook provides opportunity to manage boolean state
- * @category Utilities
- *
- * @param {boolean} [initialValue=false] The initial boolean value
- * @returns {UseBooleanReturn} An object containing the boolean state value and utility functions to manipulate the state
- *
- * @example
- * const [on, toggle] = useBoolean()
- */
-declare const useBoolean: (initialValue?: boolean) => UseBooleanReturn;
-
-/** The breakpoints type */
-type Breakpoints<Breakpoint extends string = string> = Record<Breakpoint, number>;
-/** The use breakpoints strategy */
-type UseBreakpointsStrategy = 'desktop-first' | 'mobile-first';
-/** The use breakpoints return type */
-type UseBreakpointsReturn<Breakpoint extends string = string> = {
-    /** The function that checks if the current breakpoint is greater than to the given breakpoint */
-    greater: (breakpoint: Breakpoint) => boolean;
-    /** The function that checks if the current breakpoint is greater than or equal to the given breakpoint */
-    greaterOrEqual: (breakpoint: Breakpoint) => boolean;
-    /** The function that checks if the current breakpoint is smaller than to the given breakpoint */
-    smaller: (breakpoint: Breakpoint) => boolean;
-    /** The function that checks if the current breakpoint is smaller than or equal to the given breakpoint */
-    smallerOrEqual: (breakpoint: Breakpoint) => boolean;
-    /** The function that checks if the current breakpoint is between to the given breakpoints */
-    between: (a: Breakpoint, b: Breakpoint) => boolean;
-    /** The function that checks if the current breakpoint is greater than to the given breakpoint */
-    isGreater: (breakpoint: Breakpoint) => boolean;
-    /** The function that checks if the current breakpoint is greater than or equal to the given breakpoint */
-    isGreaterOrEqual: (breakpoint: Breakpoint) => boolean;
-    /** The function that checks if the current breakpoint is smaller than to the given breakpoint */
-    isSmaller: (breakpoint: Breakpoint) => boolean;
-    /** The function that checks if the current breakpoint is smaller than or equal to the given breakpoint */
-    isSmallerOrEqual: (breakpoint: Breakpoint) => boolean;
-    /** The function that checks if the current breakpoint is between to the given breakpoints */
-    isInBetween: (a: Breakpoint, b: Breakpoint) => boolean;
-    /** The function that returns the current breakpoints */
-    current: () => Breakpoint[];
-    /** The function that returns the current active breakpoint */
-    active: () => Breakpoint;
-} & Record<Breakpoint, boolean>;
-/**
- * @name useBreakpoints
- * @description - Hook that manages breakpoints
- * @category Browser
- *
- * @template {string} Breakpoint The name of the breakpoint
- * @param {Breakpoints<Breakpoint>} breakpoints The breakpoints to use
- * @param {UseBreakpointsStrategy} [strategy=min-width] The strategy to use for matching
- * @returns {UseBreakpointsReturn<Breakpoint>} An object containing the current breakpoint
- *
- * @example
- * const { greaterOrEqual, smallerOrEqual, current } = useBreakpoints({ mobile: 0, tablet: 640, laptop: 1024, desktop: 1280 });
- */
-declare const useBreakpoints: <Breakpoint extends string>(breakpoints: Breakpoints<Breakpoint>, strategy?: UseBreakpointsStrategy) => UseBreakpointsReturn<Breakpoint>;
-/** Breakpoints from Material UI */
-declare const BREAKPOINTS_MATERIAL_UI: {
-    xs: number;
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-};
-/** Breakpoints from Mantine */
-declare const BREAKPOINTS_MANTINE: {
-    xs: number;
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-};
-/** Breakpoints from Tailwind */
-declare const BREAKPOINTS_TAILWIND: {
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-    '2xl': number;
-};
-/**  Breakpoints from Bootstrap V5 */
-declare const BREAKPOINTS_BOOTSTRAP_V5: {
-    xs: number;
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-    xxl: number;
-};
-/** Breakpoints from Ant Design */
-declare const BREAKPOINTS_ANT_DESIGN: {
-    xs: number;
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-    xxl: number;
-};
-/** Breakpoints from Quasar V2 */
-declare const BREAKPOINTS_QUASAR_V2: {
-    xs: number;
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-};
-/** Sematic Breakpoints */
-declare const BREAKPOINTS_SEMANTIC: {
-    mobileS: number;
-    mobileM: number;
-    mobileL: number;
-    tablet: number;
-    laptop: number;
-    laptopL: number;
-    desktop4K: number;
-};
-/**  Breakpoints from Master CSS  */
-declare const BREAKPOINTS_MASTER_CSS: {
-    '3xs': number;
-    '2xs': number;
-    xs: number;
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-    '2xl': number;
-    '3xl': number;
-    '4xl': number;
-};
-/** Breakpoints from PrimeFlex */
-declare const BREAKPOINTS_PRIME_FLEX: {
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-};
-
-/**
- * @name useBrowserLanguage
- * @description - Hook that returns the current browser language
- * @category Browser
- *
- * @browserapi navigator.language https://developer.mozilla.org/en-US/docs/Web/API/Navigator/language
- *
- * @returns {string} The current browser language
- *
- * @example
- * const browserLanguage = useBrowserLanguage();
- */
-declare const useBrowserLanguage: () => string;
-
-interface StateRef<Value> {
-    (node: Value): void;
-    current: Value;
-    state?: Value;
-}
-/**
- * @name useRefState
- * @description - Hook that returns the state reference of the value
- * @category Utilities
- *
- * @template Value The type of the value
- * @param {Value} [initialValue] The initial value
- * @returns {StateRef<Value>} The current value
- *
- * @example
- * const internalRefState = useRefState();
- */
-declare const useRefState: <Value>(initialValue?: Value) => StateRef<Value>;
-
-interface UseClickOutside {
-    (target: HookTarget$1, callback: (event: Event) => void): void;
-    <Target extends Element>(callback: (event: Event) => void, target?: never): StateRef<Target>;
-}
-/**
- * @name useClickOutside
- * @description - Hook to handle click events outside the specified target element(s)
- * @category Sensors
- *
- * @overload
- * @param {HookTarget} target The target element(s) to detect outside clicks for
- * @param {(event: Event) => void} callback The callback to execute when a click outside the target is detected
- * @returns {void}
- *
- * @example
- * useClickOutside(ref, () => console.log('click outside'));
- *
- * @overload
- * @template Target The target element(s)
- * @param {(event: Event) => void} callback The callback to execute when a click outside the target is detected
- * @returns {(node: Target) => void} A React ref to attach to the target element
- *
- * @example
- * const ref = useClickOutside<HTMLDivElement>(() => console.log('click outside'));
- */
-declare const useClickOutside: UseClickOutside;
-
-/** The use copy to clipboard return type */
-interface UseCopyToClipboardReturn {
-    /** The copied value */
-    value: string | null;
-    /** Function to copy to clipboard  */
-    copy: (value: string) => Promise<void>;
-}
-/** The use copy to clipboard params type */
-interface UseCopyToClipboardParams {
-    /** Whether the copy to clipboard is enabled */
-    enabled: boolean;
-}
-/**
- * @name useClipboard
- * @description - Hook that manages a copy to clipboard
- * @category Browser
- *
- * @browserapi navigator.clipboard https://developer.mozilla.org/en-US/docs/Web/API/Navigator/clipboard
- *
- * @param {boolean} [params.enabled=false] Whether the copy to clipboard is enabled
- * @returns {UseCopyToClipboardReturn} An object containing the boolean state value and utility functions to manipulate the state
- *
- * @example
- * const { supported, value, copy } = useClipboard();
- */
-declare const useClipboard: (params?: UseCopyToClipboardParams) => UseCopyToClipboardReturn;
-
-/**
- * @name useConst
- * @description - Hook that returns the constant value
- * @category Utilities
- *
- * @template Value The type of the value
- * @param {(() => Value) | Value} initialValue The initial value of the constant
- * @returns {Value} The constant value
- *
- * @example
- * const value = useConst('value');
- */
-declare const useConst: <Value>(initialValue: (() => Value) | Value) => Value;
-
-declare const getCookies: () => {
-    [k: string]: string;
-};
-interface RemoveCookieParams {
-    domain?: string;
-    expires?: Date;
-    maxAge?: number;
-    path?: string;
-    sameSite?: 'Lax' | 'None' | 'Strict';
-    secure?: boolean;
-}
-declare const removeCookie: (key: string, options?: RemoveCookieParams) => void;
-interface SetCookieParams {
-    domain?: string;
-    expires?: Date;
-    httpOnly?: boolean;
-    maxAge?: number;
-    path?: string;
-    sameSite?: 'Lax' | 'None' | 'Strict';
-    secure?: boolean;
-}
-declare const setCookie: (key: string, value: string, options?: SetCookieParams) => void;
-type UseCookieInitialValue<Value> = (() => Value) | Value;
-interface UseCookieOptions<Value> {
-    domain?: string;
-    expires?: Date;
-    httpOnly?: boolean;
-    initialValue?: UseCookieInitialValue<Value>;
-    maxAge?: number;
-    path?: string;
-    sameSite?: 'Lax' | 'None' | 'Strict';
-    secure?: boolean;
-    updateOnChange?: boolean;
-    deserializer?: (value: string) => Value;
-    serializer?: (value: Value) => string;
-}
-interface UseCookieReturn<Value> {
-    value: Value;
-    remove: (options?: RemoveCookieParams) => void;
-    set: (value: Value, options?: SetCookieParams) => void;
-}
-declare const COOKIE_EVENT = "reactuse-cookie";
-declare const dispatchCookieEvent: () => boolean;
-declare const setCookieItem: (key: string, value: string, options?: SetCookieParams) => void;
-declare const removeCookieItem: (key: string, options?: RemoveCookieParams) => void;
-declare const getCookie: (key: string) => string | undefined;
-/**
- * @name useCookie
- * @description - Hook that manages cookie value
- * @category Browser
- *
- * @overload
- * @template Value The type of the cookie value
- * @param {string} key The key of the cookie
- * @param {UseCookieInitialValue<Value>} [initialValue] The initial value of the cookie
- * @returns {UseCookieReturn<Value>} The value and the set function
- *
- * @example
- * const { value, set, remove } = useCookie('key', 'value');
- */
-declare const useCookie: <Value>(key: string, params?: UseCookieInitialValue<Value> | UseCookieOptions<Value>) => {
-    value: Value | undefined;
-    set: (value: Value, params?: SetCookieParams) => void;
-    remove: (params?: RemoveCookieParams) => void;
-};
-
-declare const getParsedCookies: () => {
-    [k: string]: any;
-};
-declare const clearCookies: () => void;
-/**
- * @name useCookies
- * @description - Hook that manages cookie values
- * @category Browser
- *
- * @overload
- * @template {object} Value The type of the cookie values
- * @param {string} key The key of the cookie
- * @returns {UseCookieReturn<Value>} The value and the set function
- *
- * @example
- * const { value, set, remove, getAll, clear } = useCookies();
- */
-declare const useCookies: <Value>() => {
-    value: Value;
-    set: (key: string, value: Value, options?: SetCookieParams) => void;
-    remove: (key: string, options?: RemoveCookieParams) => void;
-    getAll: () => {
-        [k: string]: any;
-    };
-    clear: () => void;
-};
-
-/** The use copy return type */
-interface UseCopyReturn {
-    /** Whether copy is in progress */
-    copied: boolean;
-    /** The copied value */
-    value: string | null;
-    /** Function to copy text */
-    copy: (value: string) => Promise<void>;
-}
-/** The use copy params type */
-interface UseCopyParams {
-    /** Reset delay in milliseconds */
-    resetDelay?: number;
-}
-/**
- * @name useCopy
- * @description - Hook that manages copying text with status reset
- * @category Browser
- *
- * @browserapi navigator.clipboard https://developer.mozilla.org/en-US/docs/Web/API/Navigator/clipboard
- *
- * @param {number} [delay=1000] Delay in ms before resetting copied status
- * @returns {UseCopyReturn} An object containing the copied value, status and copy function
- *
- * @example
- * const { copied, value, copy } = useCopy();
- */
-declare const useCopy: (delay?: number) => UseCopyReturn;
-
-/** The use counter options */
-interface UseCounterOptions {
-    /** The max of count value */
-    max?: number;
-    /** The min of count value */
-    min?: number;
-}
-/** The use counter return type */
-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;
-}
-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 });
- */
-declare const useCounter: UseCounter;
-
-/** The css variable return type */
-interface UseCssVarReturn {
-    /** The value of the CSS variable */
-    value: string;
-    /** Set the value of the CSS variable */
-    set: (value: string) => void;
-}
-interface UseCssVar {
-    (key: string, initialValue?: string): UseCssVarReturn & {
-        ref: StateRef<Element>;
-    };
-    (target: HookTarget$1, 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');
- */
-declare const useCssVar: UseCssVar;
-
-/**
- * @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);
- */
-declare const useDebounceCallback: <Params extends unknown[], Return>(callback: (...args: Params) => Return, delay: number) => (...args: Params) => void;
-
-/**
- * @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);
- */
-declare const useDebounceValue: <Value>(value: Value, delay: number) => Value;
-
-/**
- * @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);
- */
-declare const useDefault: <Value>(initialValue: (() => Value) | Value, defaultValue: Value) => readonly [Value, react.Dispatch<react.SetStateAction<Value | null | undefined>>];
-
-interface UseDeviceMotionReturn {
-    acceleration: DeviceMotionEventAcceleration;
-    accelerationIncludingGravity: DeviceMotionEventAcceleration;
-    interval: DeviceMotionEvent['interval'];
-    rotationRate: DeviceMotionEventRotationRate;
-}
-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();
- */
-declare const useDeviceMotion: (params?: UseDeviceMotionParams) => UseDeviceMotionReturn;
-
-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;
-}
-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();
- */
-declare const useDeviceOrientation: () => UseDeviceOrientationReturn;
-
-/** The use device pixel ratio return type */
-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();
- */
-declare const useDevicePixelRatio: () => UseDevicePixelRatioReturn;
-
-/**
- * @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]);
- */
-declare const useDidUpdate: (effect: EffectCallback, deps?: DependencyList) => void;
-
-/** The use disclosure options type */
-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 */
-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();
- */
-declare const useDisclosure: (initialValue?: boolean, options?: UseDisclosureOptions) => UseDisclosureReturn;
-
-/** The use display media return type */
-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 */
-interface UseDisplayMediaOptions {
-    /** Whether to enable audio sharing */
-    audio?: boolean | MediaTrackConstraints;
-    /** Whether to start immediately */
-    immediately?: boolean;
-    /** Whether to enable video sharing */
-    video?: boolean | MediaTrackConstraints;
-}
-interface UseDisplayMedia {
-    (target: HookTarget$1, 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>();
- */
-declare const useDisplayMedia: UseDisplayMedia;
-
-/** The use event listener options */
-type UseEventListenerOptions = boolean | AddEventListenerOptions;
-/** The use event listener return type */
-type UseEventListenerReturn<Target extends Element> = StateRef<Target>;
-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$1, 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'));
- */
-declare const 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'));
- */
-declare const useDocumentEvent: <Event extends keyof DocumentEventMap>(event: Event, listener: (this: Document, event: DocumentEventMap[Event]) => any, options?: UseEventListenerOptions) => void;
-
-/** The use document title options type */
-interface UseDocumentTitleOptions {
-    /** Restore the previous title on unmount */
-    restoreOnUnmount?: boolean;
-}
-/** The use document title return type */
-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();
- */
-declare function useDocumentTitle(initialValue?: string, options?: UseDocumentTitleOptions): UseDocumentTitleReturn;
-
-/**
- * @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();
- */
-declare const useDocumentVisibility: () => DocumentVisibilityState;
-
-/** The element size value type */
-interface UseElementSizeValue {
-    /** The element's height */
-    height: number;
-    /** The element's width */
-    width: number;
-}
-/** The use element size return type */
-interface UseElementSizeReturn {
-    value: UseElementSizeValue;
-}
-interface UseElementSize {
-    (target: HookTarget$1): 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();
- */
-declare const useElementSize: UseElementSize;
-
-/**
- * @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'));
- */
-declare const useEvent: <Params extends unknown[], Return>(callback: (...args: Params) => Return) => ((...args: Params) => Return);
-
-interface ColorSelectionOptions {
-    signal?: AbortSignal;
-}
-interface ColorSelectionResult {
-    sRGBHex: string;
-}
-interface EyeDropper {
-    open: (options?: ColorSelectionOptions) => Promise<ColorSelectionResult>;
-}
-interface EyeDropperConstructor {
-    new (): EyeDropper;
-}
-declare global {
-    interface Window {
-        readonly EyeDropper?: EyeDropperConstructor | undefined;
-    }
-}
-/** The color selection return type */
-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();
- */
-declare const useEyeDropper: (initialValue?: string | undefined) => UseEyeDropperReturn;
-
-/** The use favicon return type */
-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');
- */
-declare const useFavicon: (initialHref?: string) => {
-    readonly href: string | undefined;
-    readonly set: (favicon: string) => void;
-};
-
-/** The use field params type */
-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 */
-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 */
-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();
- */
-declare const useField: <Value extends boolean | number | string = string, Type = Value extends string ? string : Value extends boolean ? boolean : number>(params?: UseFieldParams<Value>) => UseFieldReturn<Type>;
-
-interface UseFileDialogOptions extends Pick<ComponentProps<'input'>, 'accept' | 'multiple'> {
-    /** The capture value */
-    capture?: string;
-    /** The reset value */
-    reset?: boolean;
-}
-interface UseFileDialogReturn {
-    /** The selected files */
-    value: FileList | null;
-    /** The open function */
-    open: (openParams?: UseFileDialogOptions) => void;
-    /** The reset function */
-    reset: () => void;
-}
-interface UseFileDialog {
-    (callback?: (value: FileList | null) => void, options?: UseFileDialogOptions): UseFileDialogReturn;
-    (options?: UseFileDialogOptions, callback?: never): UseFileDialogReturn;
-}
-/**
- * @name useFileDialog
- * @description - Hook to handle file input
- * @category Browser
- *
- * @overload
- * @param {(value: FileList | null) => void} callback The callback to execute when a file is selected
- * @param {boolean} [options.multiple=true] Whether multiple files can be selected
- * @param {string} [options.accept='*'] The accepted file types
- * @param {boolean} [options.reset=false] Whether the input should be reset when the callback is called
- * @param {string} [options.capture] The capture value
- * @returns {UseFileDialogReturn} An object containing the selected files
- *
- * @example
- * const { values, open, reset } = useFileDialog((value) => console.log(value));
- *
- * @overload
- * @param {boolean} [options.multiple=true] Whether multiple files can be selected
- * @param {string} [options.accept='*'] The accepted file types
- * @param {boolean} [options.reset=false] Whether the input should be reset when the callback is called
- * @param {string} [options.capture] The capture value
- * @returns {UseFileDialogReturn} An object containing the selected files
- *
- * @example
- * const { values, open, reset } = useFileDialog({ accept: 'image/*' });
- */
-declare const useFileDialog: UseFileDialog;
-
-/** The use focus options type */
-interface UseFocusOptions {
-    /** The initial focus state of the target */
-    initialValue?: boolean;
-    /** The on blur callback */
-    onBlur?: (event: FocusEvent) => void;
-    /** The on focus callback */
-    onFocus?: (event: FocusEvent) => void;
-}
-/** The use focus return type */
-interface UseFocusReturn {
-    /** The boolean state value of the target */
-    focused: boolean;
-    /** Blur the target */
-    blur: () => void;
-    /** Focus the target */
-    focus: () => void;
-}
-interface UseFocus {
-    (target: HookTarget$1, options?: UseFocusOptions): UseFocusReturn;
-    <Target extends Element>(options?: UseFocusOptions, target?: never): UseFocusReturn & {
-        ref: StateRef<Target>;
-    };
-}
-/**
- * @name useFocus
- * @description - Hook that allows you to focus on a specific element
- * @category Browser
- *
- * @overload
- * @param {HookTarget} target The target element to focus
- * @param {boolean} [options.initialValue=false] The initial focus state of the target
- * @param {(event: FocusEvent) => void} [options.onFocus] The callback function to be invoked on focus
- * @param {(event: FocusEvent) => void} [options.onBlur] The callback function to be invoked on blur
- * @returns {UseFocusReturn} An object with focus state and methods
- *
- * @example
- * const { focus, blur, focused } = useFocus(ref);
- *
- * @overload
- * @template Target The target element
- * @param {boolean} [options.initialValue=false] The initial focus state of the target
- * @param {(event: FocusEvent) => void} [options.onFocus] The callback function to be invoked on focus
- * @param {(event: FocusEvent) => void} [options.onBlur] The callback function to be invoked on blur
- * @returns {UseFocusReturn & { ref: StateRef<Target> }} An object with focus state, methods and ref
- *
- * @example
- * const { ref, focus, blur, focused } = useFocus();
- */
-declare const useFocus: UseFocus;
-
-/**
- * @name useFps
- * @description - Hook that measures frames per second
- * @category Sensors
- *
- * @browserapi requestAnimationFrame https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame
- *
- * @returns {number} A number which determines frames per second
- *
- * @example
- * const fps = useFps();
- */
-declare const useFps: () => number;
-
-/** The use fullscreen options type */
-interface UseFullScreenOptions {
-    /** initial value */
-    initialValue?: boolean;
-    /** on enter fullscreen */
-    onEnter?: () => void;
-    /** on exit fullscreen */
-    onExit?: () => void;
-}
-/** The use click outside return type */
-interface UseFullScreenReturn {
-    /** The fullscreen state */
-    value: boolean;
-    /** The fullscreen enter method */
-    enter: () => void;
-    /** The fullscreen exit method */
-    exit: () => void;
-    /** The fullscreen toggle method */
-    toggle: () => void;
-}
-interface UseFullScreen {
-    (target: HookTarget$1, options?: UseFullScreenOptions): UseFullScreenReturn;
-    <Target extends Element>(options?: UseFullScreenOptions, target?: never): UseFullScreenReturn & {
-        ref: StateRef<Target>;
-    };
-}
-/**
- * @name useFullscreen
- * @description - Hook to handle fullscreen events
- * @category Browser
- *
- * @overload
- * @param {HookTarget} target The target element for fullscreen
- * @param {boolean} [options.initialValue=false] initial value of fullscreen
- * @param {() => void} [options.onEnter] on enter fullscreen
- * @param {() => void} [options.onExit] on exit fullscreen
- * @returns {UseFullScreenReturn} An object with the fullscreen state and methods
- *
- * @example
- * const { enter, exit, toggle, value } = useFullscreen(ref);
- *
- * @overload
- * @template Target The target element for fullscreen
- * @param {boolean} [options.initialValue=false] initial value of fullscreen
- * @param {() => void} [options.onEnter] on enter fullscreen
- * @param {() => void} [options.onExit] on exit fullscreen
- * @returns {UseFullScreenReturn & { ref: RefObject<Target> }} An object with the fullscreen state and methods
- *
- * @example
- * const { ref, enter, exit, toggle, value } = useFullscreen();
- */
-declare const useFullscreen: UseFullScreen;
-
-declare global {
-    interface Gamepad {
-        hapticActuators?: GamepadHapticActuator[];
-    }
-}
-/** The use gamepad return type  */
-interface UseGamepadStateReturn {
-    /** The gamepad active status */
-    active: boolean;
-    /** The gamepad state */
-    gamepads: Gamepad[];
-    /** The gamepad supported status */
-    supported: boolean;
-}
-/**
- * @name useGamepad
- * @description - Hook for getting information about gamepad
- * @category Browser
- *
- * @browserapi navigator.getGamepads https://developer.mozilla.org/en-US/docs/Web/API/Navigator/getGamepads
- *
- * @returns {UseGamepadStateReturn} An object containing the gamepad information
- *
- * @example
- * const { supported, gamepads, active } = useGamepad();
- */
-declare const useGamepad: () => {
-    active: boolean;
-    supported: boolean;
-    gamepads: Gamepad[];
-};
-declare const mapGamepadToXbox360Controller: (gamepad: Gamepad) => {
-    buttons: {
-        a: GamepadButton;
-        b: GamepadButton;
-        x: GamepadButton;
-        y: GamepadButton;
-    };
-    bumper: {
-        left: GamepadButton;
-        right: GamepadButton;
-    };
-    triggers: {
-        left: GamepadButton;
-        right: GamepadButton;
-    };
-    stick: {
-        left: {
-            horizontal: number;
-            vertical: number;
-            button: GamepadButton;
-        };
-        right: {
-            horizontal: number;
-            vertical: number;
-            button: GamepadButton;
-        };
-    };
-    dpad: {
-        up: GamepadButton;
-        down: GamepadButton;
-        left: GamepadButton;
-        right: GamepadButton;
-    };
-    back: GamepadButton;
-    start: GamepadButton;
-};
-
-/** The use geolocation return type */
-interface UseGeolocationReturn {
-    /** The accuracy of the last position update */
-    accuracy: number | null;
-    /** The altitude of the last position update */
-    altitude: number | null;
-    /** The altitude accuracy of the last position update */
-    altitudeAccuracy: number | null;
-    /** The error of the last position update */
-    error: GeolocationPositionError | null;
-    /** The heading of the last position update */
-    heading: number | null;
-    /** The latitude of the last position update */
-    latitude: number | null;
-    /** The loading state */
-    loading: boolean;
-    /** The longitude of the last position update */
-    longitude: number | null;
-    /** The speed of the last position update */
-    speed: number | null;
-    /** The timestamp of the last position update */
-    timestamp: number | null;
-}
-/** The use geolocation params type */
-type UseGeolocationParams = PositionOptions;
-/**
- * @name useGeolocation
- * @description - Hook that returns the current geolocation
- * @category Browser
- *
- * @browserapi navigator.geolocation https://developer.mozilla.org/en-US/docs/Web/API/Navigator/geolocation
- *
- * @param {boolean} [params.enableHighAccuracy] Enable high accuracy
- * @param {number} [params.maximumAge] Maximum age
- * @param {number} [params.timeout] Timeout
- * @returns {UseGeolocationReturn}
- *
- * @example
- * const { loading, error, timestamp, accuracy, latitude, longitude, altitude, altitudeAccuracy, heading, speed } = useGeolocation();
- */
-declare const useGeolocation: (params?: UseGeolocationParams) => UseGeolocationReturn;
-
-/** The use hash return type */
-type UseHashReturn = [string, (value: string) => void];
-/**
- * @name useHash
- * @description - Hook that manages the hash value
- * @category Browser
- *
- * @returns {UseHashReturn} An array containing the hash value and a function to set the hash value
- *
- * @example
- * const [hash, setHash] = useHash();
- */
-declare const useHash: () => UseHashReturn;
-
-/** The use hotkeys params type */
-interface UseHotkeysOptions {
-    /** Alias map for hotkeys */
-    alias?: Record<string, string>;
-    /** Enable or disable the event listeners */
-    enabled?: boolean;
-}
-declare const isHotkeyMatch: (hotkey: string, keys: UseHotkeysKey[]) => boolean;
-/** The hotkeys string type */
-type UseHotkeysHotkeys = string;
-/** The hotkey key information */
-interface UseHotkeysKey {
-    /** The alias for the key */
-    alias: string;
-    /** The key code */
-    code: string;
-    /** The key value */
-    key: string;
-}
-/** The use hotkeys target type */
-type UseHotkeysTarget = Element | React.RefObject<Element | null | undefined>;
-interface UseHotkeys {
-    (target: UseHotkeysTarget, hotkeys: UseHotkeysHotkeys, callback: (event: KeyboardEvent) => void, options?: UseHotkeysOptions): void;
-    <Target extends Element>(hotkeys: UseHotkeysHotkeys, callback: (event: KeyboardEvent) => void, options?: UseHotkeysOptions, target?: never): StateRef<Target>;
-}
-/**
- * @name useHotkeys
- * @description - Hook that listens for hotkeys
- * @category Sensors
- *
- * @overload
- * @param {HookTarget} [target=window] The target element to attach the event listener to
- * @param {string} hotkeys The hotkey to listen for
- * @param {(event: KeyboardEvent) => void} callback The callback function to execute when hotkey is pressed
- * @param {Record<string, string>} [options.alias] Alias map for hotkeys
- * @param {boolean} [options.enabled=true] Enable or disable the event listeners
- * @returns {void}
- *
- * @example
- * useHotkeys(ref, 'ctrl+a', () => console.log('hotkey pressed'));
- * @example
- * useHotkeys(ref, 'ctrl+a, ctrl+b', () => console.log('hotkey pressed'));
- *
- * @overload
- * @template Target The target element
- * @param {string} hotkeys The hotkey to listen for
- * @param {(event: KeyboardEvent) => void} callback The callback function to execute when hotkey is pressed
- * @param {Record<string, string>} [options.alias] Alias map for hotkeys
- * @param {boolean} [options.enabled=true] Enable or disable the event listeners
- * @returns {StateRef<Target>} A reference to the target element
- *
- * @example
- * const ref = useHotkeys('ctrl+a', () => console.log('hotkey pressed'));
- * @example
- * const ref = useHotkeys('ctrl+a, ctrl+b', () => console.log('hotkey pressed'));
- */
-declare const useHotkeys: UseHotkeys;
-
-/** The use hover options type */
-interface UseHoverOptions {
-    /** The on entry callback */
-    onEntry?: (event: Event) => void;
-    /** The on leave callback */
-    onLeave?: (event: Event) => void;
-}
-interface UseHover {
-    (target: HookTarget$1, callback?: (event: Event) => void): boolean;
-    (target: HookTarget$1, options?: UseHoverOptions): boolean;
-    <Target extends Element>(callback?: (event: Event) => void, target?: never): [StateRef<Target>, boolean];
-    <Target extends Element>(options?: UseHoverOptions, target?: never): [StateRef<Target>, boolean];
-}
-/**
- * @name useHover
- * @description - Hook that defines the logic when hovering an element
- * @category Sensors
- *
- * @overload
- * @param {HookTarget} target The target element to be hovered
- * @param {(event: Event) => void} [callback] The callback function to be invoked on mouse enter
- * @returns {boolean} The state of the hover
- *
- * @example
- * const hovering = useHover(ref, () => console.log('callback'));
- *
- * @overload
- * @param {HookTarget} target The target element to be hovered
- * @param {(event: Event) => void} [options.onEntry] The callback function to be invoked on mouse enter
- * @param {(event: Event) => void} [options.onLeave] The callback function to be invoked on mouse leave
- * @returns {boolean} The state of the hover
- *
- * @example
- * const hovering = useHover(ref, options);
- *
- * @overload
- * @template Target The target element
- * @param {(event: Event) => void} [callback] The callback function to be invoked on mouse enter
- * @returns {UseHoverReturn<Target>} The state of the hover
- *
- * @example
- * const [ref, hovering] = useHover(() => console.log('callback'));
- *
- * @overload
- * @template Target The target element
- * @param {(event: Event) => void} [options.onEntry] The callback function to be invoked on mouse enter
- * @param {(event: Event) => void} [options.onLeave] The callback function to be invoked on mouse leave
- * @returns {UseHoverReturn<Target>} The state of the hover
- *
- * @example
- * const [ref, hovering] = useHover(options);
- */
-declare const useHover: UseHover;
-
-/** The use idle options type */
-interface UseIdleOptions {
-    /** The idle events */
-    events?: Array<keyof DocumentEventMap>;
-    /** The idle state */
-    initialValue?: boolean;
-}
-/** The use idle return type */
-interface UseIdleReturn {
-    /** The idle state */
-    idle: boolean;
-    /** The last active time */
-    lastActive: number;
-}
-/**
- * @name useIdle
- * @description - Hook that defines the logic when the user is idle
- * @category Sensors
- *
- * @param {number} [milliseconds=ONE_MINUTE] The idle time in milliseconds
- * @param {boolean} [options.initialState=false] The options for the hook
- * @param {Array<keyof WindowEventMap>} [options.events=IDLE_EVENTS]
- * @returns {UseIdleReturn} An object containing the idle state and the last active time
- *
- * @example
- * const { idle, lastActive } = useIdle();
- */
-declare const useIdle: (milliseconds?: number, { initialValue, events }?: UseIdleOptions) => UseIdleReturn;
-
-interface UseQueryOptions<QueryData, Data> {
-    enabled?: boolean;
-    initialData?: (() => Data) | Data;
-    keys?: DependencyList;
-    placeholderData?: (() => Data) | Data;
-    refetchInterval?: number;
-    retry?: boolean | number;
-    retryDelay?: ((retry: number, error: Error) => number) | number;
-    onError?: (error: Error) => void;
-    onSuccess?: (data: Data) => void;
-    select?: (data: QueryData) => Data;
-}
-interface UseQueryCallbackParams {
-    keys: DependencyList;
-    signal: AbortSignal;
-}
-interface UseQueryReturn<Data> {
-    abort: AbortController['abort'];
-    data?: Data;
-    error?: Error;
-    isError: boolean;
-    isFetching: boolean;
-    isLoading: boolean;
-    isRefetching: boolean;
-    isSuccess: boolean;
-    refetch: () => void;
-}
-/**
- * @name useQuery
- * @description - Hook that defines the logic when query data
- * @category Utilities
- *
- * @template Data The type of the data
- * @param {() => Promise<Data>} callback The callback function to be invoked
- * @param {DependencyList} [options.keys] The dependencies for the hook
- * @param {(data: Data) => void} [options.onSuccess] The callback function to be invoked on success
- * @param {(error: Error) => void} [options.onError] The callback function to be invoked on error
- * @param {UseQueryOptionsSelect<Data>} [options.select] The select function to be invoked
- * @param {Data | (() => Data)} [options.initialData] The initial data for the hook
- * @param {Data | (() => Data)} [options.placeholderData] The placeholder data for the hook
- * @param {number} [options.refetchInterval] The refetch interval
- * @param {boolean | number} [options.retry] The retry count of requests
- * @returns {UseQueryReturn<Data>} An object with the state of the query
- *
- * @example
- * const { data, isFetching, isLoading, isError, isSuccess, error, refetch, isRefetching, abort, aborted } = useQuery(() => fetch('url'));
- */
-declare const useQuery: <QueryData, Data = QueryData>(callback: (params: UseQueryCallbackParams) => Promise<QueryData>, options?: UseQueryOptions<QueryData, Data>) => UseQueryReturn<Data>;
-
-/** The use image options */
-interface UseImageOptions {
-    /** The alt of the image */
-    alt?: string;
-    /** The class of the image */
-    class?: string;
-    /** The crossorigin of the image */
-    crossorigin?: string;
-    /** The loading of the image */
-    loading?: HTMLImageElement['loading'];
-    /** The referrer policy of the image */
-    referrerPolicy?: HTMLImageElement['referrerPolicy'];
-    /** The sizes of the image */
-    sizes?: string;
-    /** The srcset of the image */
-    srcset?: string;
-}
-/** The use image return type */
-type UseImageReturn = UseQueryReturn<HTMLImageElement>;
-/**
- * @name useImage
- * @description - Hook that load an image in the browser
- * @category Browser
- *
- * @param {string} src The source of the image
- * @param {string} [options.srcset] The srcset of the image
- * @param {string} [options.sizes] The sizes of the image
- * @param {string} [options.alt] The alt of the image
- * @param {string} [options.class] The class of the image
- * @param {HTMLImageElement['loading']} [options.loading] The loading of the image
- * @param {string} [options.crossorigin] The crossorigin of the image
- * @param {HTMLImageElement['referrerPolicy']} [options.referrerPolicy] The referrerPolicy of the image
- * @param {DependencyList} [useQueryOptions.keys] The dependencies for the hook
- * @param {(data: Data) => void} [useQueryOptions.onSuccess] The callback function to be invoked on success
- * @param {(error: Error) => void} [useQueryOptions.onError] The callback function to be invoked on error
- * @param {number} [useQueryOptions.refetchInterval] The refetch interval
- * @param {boolean | number} [useQueryOptions.retry] The retry count of requests
- * @returns {UseImageReturn} An object with the state of the image
- *
- * @example
- * const { data, isLoading, isError, isSuccess, error, refetch, isRefetching } = useImage('https://example.com/image.png');
- */
-declare const useImage: (src: string, options?: UseImageOptions, useQueryOptions?: Omit<UseQueryOptions<HTMLImageElement, HTMLImageElement>, "initialData" | "placeholderData" | "select">) => UseQueryReturn<HTMLImageElement>;
-
-/** The use infinite scroll options type */
-interface UseInfiniteScrollOptions {
-    /** The direction to trigger the callback */
-    direction?: 'bottom' | 'left' | 'right' | 'top';
-    /** The distance in pixels to trigger the callback */
-    distance?: number;
-}
-interface UseInfiniteScroll {
-    (target: HookTarget$1, callback: (event: Event) => void, options?: UseInfiniteScrollOptions): boolean;
-    <Target extends Element>(callback: (event: Event) => void, options?: UseInfiniteScrollOptions, target?: never): {
-        ref: StateRef<Target>;
-        loading: boolean;
-    };
-}
-/**
- * @name useInfiniteScroll
- * @description - Hook that defines the logic for infinite scroll
- * @category Sensors
- *
- * @overload
- * @template Target The target element
- * @param {(event: Event) => void} callback The callback to execute when a click outside the target is detected
- * @param {number} [options.distance=10] The distance in pixels to trigger the callback
- * @param {string} [options.direction='bottom'] The direction to trigger the callback
- * @returns {{ ref: StateRef<Target>, loading: boolean }} An object containing the ref and loading
- *
- * @example
- * const { ref, loading } = useInfiniteScroll(() => console.log('infinite scroll'));
- *
- * @overload
- * @param {HookTarget} target The target element to detect infinite scroll for
- * @param {(event: Event) => void} callback The callback to execute when a click outside the target is detected
- * @param {number} [options.distance=10] The distance in pixels to trigger the callback
- * @param {string} [options.direction='bottom'] The direction to trigger the callback
- * @returns {boolean} A loading indicator of the infinite scroll
- *
- * @example
- * const loading = useInfiniteScroll(ref, () => console.log('infinite scroll'));
- */
-declare const useInfiniteScroll: UseInfiniteScroll;
-
-/** The intersection observer options type */
-interface UseIntersectionObserverOptions extends Omit<IntersectionObserverInit, 'root'> {
-    enabled?: boolean;
-    root?: HookTarget$1;
-    onChange?: (entry: IntersectionObserverEntry) => void;
-}
-/** The intersection observer return type */
-interface UseIntersectionObserverReturn {
-    entry?: IntersectionObserverEntry;
-    inView: boolean;
-}
-interface UseIntersectionObserver {
-    <Target extends Element>(options?: UseIntersectionObserverOptions, target?: never): UseIntersectionObserverReturn & {
-        ref: StateRef<Target>;
-    };
-    (target: HookTarget$1, options?: UseIntersectionObserverOptions): UseIntersectionObserverReturn;
-}
-/**
- * @name useIntersectionObserver
- * @description - Hook that gives you intersection observer state
- * @category Browser
- *
- * @overload
- * @param {HookTarget} target The target element to detect intersection
- * @param {boolean} [options.enabled=true] The IntersectionObserver options
- * @param {((entries: IntersectionObserverEntry[], observer: IntersectionObserver) => void) | undefined} [options.onChange] The callback to execute when intersection is detected
- * @param {HookTarget} [options.root] The root element to observe
- * @returns {UseIntersectionObserverReturn} An object containing the state and the supported status
- *
- * @example
- * const { ref, entry, inView } = useIntersectionObserver();
- *
- * @overload
- * @template Target The target element
- * @param {boolean} [options.enabled=true] The IntersectionObserver options
- * @param {((entries: IntersectionObserverEntry[], observer: IntersectionObserver) => void) | undefined} [options.onChange] The callback to execute when intersection is detected
- * @param {HookTarget} [options.root] The root element to observe
- * @returns {UseIntersectionObserverReturn & { ref: StateRef<Target> }} A React ref to attach to the target element
- *
- * @example
- * const { entry, inView } = useIntersectionObserver(ref);
- */
-declare const useIntersectionObserver: UseIntersectionObserver;
-
-/** The use interval options */
-interface UseIntervalOptions {
-    /** Start the interval immediately */
-    immediately?: boolean;
-}
-/** The use interval return type */
-interface UseIntervalReturn {
-    /** Is the interval active */
-    active: boolean;
-    /** Pause the interval */
-    pause: () => void;
-    /** Resume the interval */
-    resume: () => void;
-    /** Toggle the interval */
-    toggle: () => void;
-}
-interface UseInterval {
-    (callback: () => void, interval?: number, options?: UseIntervalOptions): UseIntervalReturn;
-    (callback: () => void, options?: UseIntervalOptions & {
-        interval?: number;
-    }): UseIntervalReturn;
-}
-/**
- * @name useInterval
- * @description - Hook that makes and interval and returns controlling functions
- * @category Time
- *
- * @overload
- * @param {() => void} callback Any callback function
- * @param {number} [interval=1000] Time in milliseconds
- * @param {boolean} [options.immediately=true] Start the interval immediately
- * @returns {UseIntervalReturn}
- *
- * @example
- * const { active, pause, resume, toggle } = useInterval(() => console.log('inside interval'), 2500);
- *
- * @overload
- * @param {() => void} callback Any callback function
- * @param {number} [options.interval=1000] Time in milliseconds
- * @param {boolean} [options.immediately=true] Start the interval immediately
- *
- * @example
- * const { active, pause, resume, toggle } = useInterval(() => console.log('inside interval'), { interval: 2500 });
- */
-declare const useInterval: UseInterval;
-
-/**
- * @name useIsFirstRender
- * @description - Hook that returns true if the component is first render
- * @category Lifecycle
- *
- * @returns {boolean} True if the component is first render
- *
- * @example
- * const isFirstRender = useIsFirstRender();
- */
-declare const useIsFirstRender: () => boolean;
-
-/**
- * @name useIsomorphicLayoutEffect
- * @description - Hook conditionally selects either `useLayoutEffect` or `useEffect` based on the environment
- * @category Lifecycle
- *
- * @example
- * useIsomorphicLayoutEffect(() => console.log('effect'), [])
- */
-declare const useIsomorphicLayoutEffect: typeof useEffect;
-
-/** The keyboard event handler type */
-type KeyboardEventHandler = (event: KeyboardEvent) => void;
-/** The use keyboard options type */
-interface UseKeyboardOptions {
-    /** The callback function to be invoked on key down */
-    onKeyDown?: KeyboardEventHandler;
-    /** The callback function to be invoked on key up */
-    onKeyUp?: KeyboardEventHandler;
-}
-interface UseKeyboard {
-    (target: HookTarget$1 | Window, options: UseKeyboardOptions): void;
-    <Target extends Element>(options: UseKeyboardOptions, target?: never): {
-        ref: StateRef<Target>;
-    };
-}
-/**
- * @name useKeyboard
- * @description - Hook that helps to listen for keyboard events
- * @category Sensors
- *
- * @overload
- * @param {HookTarget | Window} target The target to attach the event listeners to
- * @param {UseKeyboardOptions} [options] The keyboard event options
- * @returns {void}
- *
- * @example
- * useKeyboard(ref, { onKeyDown: (event) => console.log('key down'), onKeyUp: (event) => console.log('key up') });
- *
- * @overload
- * @template Target The target element type
- * @param {UseKeyboardOptions} [options] The keyboard event options
- * @returns {{ ref: StateRef<Target> }} An object containing the ref
- *
- * @example
- * const ref = useKeyboard({ onKeyDown: (event) => console.log('key down'), onKeyUp: (event) => console.log('key up') });
- */
-declare const useKeyboard: UseKeyboard;
-
-/** The key or keys to listen for */
-type UseKeyPressKey = string | string[];
-/** The callback function to be invoked when key is pressed */
-type UseKeyPressCallback = (pressed: boolean, event: KeyboardEvent) => void;
-interface UseKeyPress {
-    (target: HookTarget$1 | Window, key: UseKeyPressKey, callback?: UseKeyPressCallback): boolean;
-    <Target extends Element>(key: UseKeyPressKey, callback?: UseKeyPressCallback, target?: never): {
-        pressed: boolean;
-        ref: StateRef<Target>;
-    };
-}
-/**
- * @name useKeyPress
- * @description - Hook that listens for key press events
- * @category Sensors
- *
- * @overload
- * @param {HookTarget} [target=window] The target to attach the event listeners to
- * @param {UseKeyPressKey} key The key or keys to listen for
- * @param {(pressed: boolean, event: KeyboardEvent) => void} [callback] Callback function invoked when key is pressed
- * @returns {boolean} The pressed state of the key
- *
- * @example
- * const isKeyPressed = useKeyPress('a', window);
- *
- * @overload
- * @template Target The target element type
- * @param {UseKeyPressKey} key The key or keys to listen for
- * @param {(pressed: boolean, event: KeyboardEvent) => void} [callback] Callback function invoked when key is pressed
- * @returns {{ pressed: boolean; ref: StateRef<Target> }} An object containing the pressed state and ref
- *
- * @example
- * const { pressed, ref } = useKeyPress('a');
- */
-declare const useKeyPress: UseKeyPress;
-
-/** The key or keys to listen for */
-type UseKeyPressEventKey = string | string[];
-/** The use key press event options type */
-interface UseKeyPressEventOptions {
-    /** Whether the event should be captured */
-    capture?: boolean;
-    /** Whether the event listener should only be triggered once */
-    once?: boolean;
-    /** Whether the event listener should be passive */
-    passive?: boolean;
-}
-interface UseKeyPressEvent {
-    (target: HookTarget$1 | Window, key: UseKeyPressEventKey, listener: (event: KeyboardEvent) => void, options?: UseKeyPressEventOptions): void;
-    <Target extends Element>(key: UseKeyPressEventKey, listener: (event: KeyboardEvent) => void, options?: UseKeyPressEventOptions, target?: never): {
-        ref: StateRef<Target>;
-    };
-}
-/**
- * @name useKeyPressEvent
- * @description - Hook that listens for key press events on specified targets
- * @category Sensors
- *
- * @overload
- * @param {UseKeyPressEventKey} key The key or array of keys to listen for.
- * @param {HookTarget | Window} target The target to attach the event listener to.
- * @param {(event: KeyboardEvent) => void} listener The callback function to be executed when the specified key or keys are pressed.
- * @param {UseKeyPressEventOptions} [options] The options for the event listener.
- * @returns {void}
- *
- * @example
- * useKeyPressEvent(ref, 'Enter', () => console.log('pressed'));
- *
- * @overload
- * @template Target extends Element
- * @param {UseKeyPressEventKey} key The key or array of keys to listen for.
- * @param {(event: KeyboardEvent) => void} listener The callback function to be executed when the specified key or keys are pressed.
- * @param {UseKeyPressEventOptions} [options] The options for the event listener.
- * @returns {{ ref: StateRef<Target> }} An object containing the ref
- *
- * @example
- * const ref = useKeyPressEvent('Enter', (event) => console.log('pressed'));
- */
-declare const useKeyPressEvent: UseKeyPressEvent;
-
-/** The use keys pressed options type */
-interface UseKeysPressedOptions {
-    /** Enable or disable the event listeners */
-    enabled?: boolean;
-}
-interface UseKeysPressed {
-    (target: HookTarget$1 | Window, options?: UseKeysPressedOptions): Array<{
-        key: string;
-        code: string;
-    }>;
-    <Target extends Element>(options?: UseKeysPressedOptions): {
-        value: Array<{
-            key: string;
-            code: string;
-        }>;
-        ref: StateRef<Target>;
-    };
-}
-/**
- * Hook that tracks which keyboard keys are currently pressed
- *
- * @name useKeysPressed
- * @description Tracks all currently pressed keyboard keys and their codes
- * @category Sensors
- *
- * @overload
- * @param {HookTarget | Window} target DOM element or ref to attach keyboard listeners to
- * @param {UseKeysPressedOptions} [options.enabled=true] Enable or disable the event listeners
- * @returns {Array<{ key: string; code: string }>} Array of currently pressed keys with their key and code values
- *
- * @example
- * const pressedKeys = useKeysPressed(ref);
- *
- * @overload
- * @template Target - Type of the target DOM element
- * @param {UseKeysPressedOptions} [options] - Optional configuration options
- * @returns {{ keys: Array<{ key: string; code: string }>; ref: StateRef<Target> }} Object containing pressed keys array and ref to attach to a DOM element
- *
- * @example
- * const { value, ref } = useKeysPressed();
- */
-declare const useKeysPressed: UseKeysPressed;
-
-/** The use last changed options type  */
-interface UseLastChangedOptions {
-    initialValue?: number;
-}
-/**
- * @name useLastChanged
- * @description - Hook for records the timestamp of the last change
- * @category Time
- *
- * @param {any} source  The source of the last change
- * @param {number | null} [options.initialValue=null] The initial value
- * @returns {number | null} Return timestamp of the last change
- *
- * @example
- * const lastChanged = useLastChanged(source);
- */
-declare const useLastChanged: (source: any, options?: UseLastChangedOptions) => number | null;
-
-/**
- * @name useLatest
- * @description - Hook that returns the stable reference of the value
- * @category Utilities
- *
- * @template Value The type of the value
- * @param {Value} value The value to get the previous value
- * @returns {Value} The previous value
- *
- * @example
- * const latestValue = useLatest(value);
- */
-declare const useLatest: <Value>(value: Value) => Value;
-
-/**
- * @name useLess
- * @description - Hook that can be so useless
- * @category Humor
- *
- * @warning - This hook is a joke. Please do not use it in production code!
- *
- * @template Value The type of the value
- * @param {Value} [value] The value to be returned
- * @returns {Value} The value passed to the hook
- *
- * @example
- * const value = useLess(state);
- */
-declare const useLess: <Value>(value?: Value) => Value | undefined;
-
-/** The use list return type */
-interface UseListReturn<Item> {
-    /** The current list of items */
-    value: Item[];
-    /** Clears the list */
-    clear: () => void;
-    /** Inserts an item at the specified index */
-    insertAt: (insertAtIndex: number, item: Item) => void;
-    /** Adds an item to the list */
-    push: (item: Item) => void;
-    /** Removes an item from the list */
-    removeAt: (removeAtIndex: number) => void;
-    /** Sets the list of items */
-    set: (list: Item[]) => void;
-    /** Updates an item at the specified index */
-    updateAt: (updateAtIndex: number, item: Item) => void;
-}
-/**
- * @name useList
- * @description - Hook that provides state and helper methods to manage a list of items
- * @category Utilities
- *
- * @template Item The type of the item
- * @param {Item[] | (() => Item[])} initialList The initial list of items
- * @returns {UseListReturn} An object containing the current list and functions to interact with the list
- *
- * @example
- * const { value, set, push, removeAt, insertAt, updateAt, clear } = useList();
- */
-declare const useList: <Item>(initialList?: Item[]) => {
-    value: Item[];
-    set: react.Dispatch<react.SetStateAction<Item[]>>;
-    push: (item: Item) => void;
-    removeAt: (removeAtIndex: number) => void;
-    insertAt: (insertAtIndex: number, item: Item) => void;
-    updateAt: (updateAtIndex: number, item: Item) => void;
-    clear: () => void;
-    reset: () => void;
-};
-
-type UseStorageInitialValue<Value> = (() => Value) | Value;
-interface UseStorageOptions<Value> {
-    initialValue?: UseStorageInitialValue<Value>;
-    storage?: Storage;
-    deserializer?: (value: string) => Value;
-    serializer?: (value: Value) => string;
-}
-interface UseStorageReturn<Value> {
-    value: Value;
-    remove: () => void;
-    set: (value: Value) => void;
-}
-declare const STORAGE_EVENT = "reactuse-storage";
-declare const dispatchStorageEvent: (params: Partial<StorageEvent>) => boolean;
-/**
- * @name useStorage
- * @description - Hook that manages storage value
- * @category Browser
- *
- * @overload
- * @param {string} key The key of the storage
- * @param {UseStorageInitialValue<Value>} [initialValue] The initial value of the storage
- * @returns {UseStorageReturn<Value>} The value and the set function
- *
- * @overload
- * @param {string} key The key of the storage
- * @param {(value: Value) => string} [params.serializer] The serializer function
- * @param {(value: string) => Value} [params.deserializer] The deserializer function
- * @param {Storage} [params.storage] The storage
- * @param {UseStorageInitialValue<Value>} [params.initialValue] The initial value of the storage
- * @returns {UseStorageReturn<Value>} The value and the set function
- *
- * @example
- * const { value, set, remove } = useStorage('key', 'value');
- */
-declare const useStorage: <Value>(key: string, params?: UseStorageInitialValue<Value> | UseStorageOptions<Value>) => {
-    value: Value | undefined;
-    set: (value: Value) => void;
-    remove: () => void;
-};
-
-/**
- * @name useLocalStorage
- * @description - Hook that manages local storage value
- * @category Browser
- *
- * @browserapi localStorage https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage
- *
- * @template Value The type of the value
- * @param {string} key The key of the storage
- * @param {UseStorageInitialValue<Value>} [initialValue] The initial value of the storage
- * @param {UseStorageOptions<Value>} [options] The options of the storage
- *
- * @example
- * const { value, set, remove } = useLocalStorage('key', 'value');
- */
-declare const useLocalStorage: <Value>(key: string, initialValue?: UseStorageInitialValue<Value>, options?: Omit<UseStorageOptions<Value>, "initialValue" | "storage">) => {
-    value: Value | undefined;
-    set: (value: Value) => void;
-    remove: () => void;
-};
-
-/**
- * @name useLockCallback
- * @description - Hook that prevents a callback from being executed multiple times simultaneously
- * @category Utilities
- *
- * @param {Function} callback The callback to be locked
- * @returns {Function} The locked callback
- *
- * @example
- * const lockedCallback = useLockCallback(() => promise());
- */
-declare const useLockCallback: <Callback extends (...args: any[]) => any>(callback: Callback) => (...args: Parameters<Callback>) => Promise<any>;
-
-/**
- * @name useLogger
- * @description - Hook for debugging lifecycle
- * @category Lifecycle
- *
- * @param {string} name The name or identifier for the logger
- * @param {unknown[]} params Additional arguments to be logged
- *
- * @example
- * useLogger('Component', [1, 2, 3]);
- */
-declare const useLogger: (name: string, params: unknown[]) => void;
-
-type UseLongPressTarget = (() => Element) | Element | RefObject<Element | null | undefined>;
-type LongPressReactEvents<Target extends Element = Element> = MouseEventHandler<Target> | TouchEventHandler<Target>;
-interface UseLongPressOptions {
-    threshold?: number;
-    onCancel?: (event: LongPressReactEvents) => void;
-    onFinish?: (event: LongPressReactEvents) => void;
-    onStart?: (event: LongPressReactEvents) => void;
-}
-interface UseLongPressBind {
-    /** The callback function to be invoked on mouse down */
-    onMouseDown: MouseEventHandler<Element>;
-    /** The callback function to be invoked on mouse up */
-    onMouseUp: MouseEventHandler<Element>;
-    /** The callback function to be invoked on touch end */
-    onTouchEnd: TouchEventHandler<Element>;
-    /** The callback function to be invoked on touch start */
-    onTouchStart: TouchEventHandler<Element>;
-}
-type UseLongPressReturn = [UseLongPressBind, boolean];
-/**
- * @name useLongPress
- * @description - Hook that defines the logic when long pressing an element
- * @category Sensors
- *
- * @template Target The target element
- * @param {Target} target The target element to be long pressed
- * @param {(event: Event) => void} callback The callback function to be invoked on long press
- * @param {number} [options.threshold=400] The threshold time in milliseconds
- * @param {(event: Event) => void} [options.onStart] The callback function to be invoked on long press start
- * @param {(event: Event) => void} [options.onFinish] The callback function to be invoked on long press finish
- * @param {(event: Event) => void} [options.onCancel] The callback function to be invoked on long press cancel
- * @returns {UseLongPressReturn<Target>} The ref of the target element
- *
- * @example
- * const [bind, longPressing] = useLongPress(() => console.log('callback'));
- */
-declare const useLongPress: (callback: (event: LongPressReactEvents) => void, options?: UseLongPressOptions) => UseLongPressReturn;
-
-/** The use map return type */
-interface UseMapReturn<Key, Value> {
-    /** The size of the map */
-    size: number;
-    /** The current map */
-    value: Map<Key, Value>;
-    /** Function to clear the map */
-    clear: () => void;
-    /** Function to check if a value exists in the map */
-    has: (key: Key) => boolean;
-    /** Function to remove a value from the map */
-    remove: (key: Key) => void;
-    /** Function to toggle a value in the map */
-    reset: () => void;
-    /** Function to add a value to the map */
-    set: (key: Key, value: Value) => void;
-}
-/**
- * @name useMap
- * @description - Hook that manages a map structure
- * @category Utilities
- *
- * @template Value The type of the value
- * @param {Value[]} [values] The initial array of the map
- * @returns {UseMapReturn<Key, Value>} An object containing the current map and functions to interact with the map
- *
- * @example
- * const { value, set, remove, clear, reset, size, has } = useMap([1, 'one'], [2, 'two']);
- */
-declare const useMap: <Key, Value>(values?: [Key, Value][]) => UseMapReturn<Key, Value>;
-
-/** The use measure return type */
-type UseMeasureReturn = Pick<DOMRectReadOnly, 'bottom' | 'height' | 'left' | 'right' | 'top' | 'width' | 'x' | 'y'>;
-interface UseMeasure {
-    (target: HookTarget$1): UseMeasureReturn;
-    <Target extends Element>(target?: never): UseMeasureReturn & {
-        ref: StateRef<Target>;
-    };
-}
-/**
- * @name useMeasure
- * @description - Hook to measure the size and position of an element
- * @category Browser
- *
- * @overload
- * @param {HookTarget} target The element to measure
- * @returns {UseMeasureReturn} The element's size and position
- *
- * @example
- * const { x, y, width, height, top, left, bottom, right } = useMeasure(ref);
- *
- * @overload
- * @template Target The element to measure
- * @returns {UseMeasureReturn & { ref: StateRef<Target> }} The element's size and position
- *
- * @example
- * const { ref, x, y, width, height, top, left, bottom, right } = useMeasure();
- */
-declare const useMeasure: UseMeasure;
-
-/**
- * @name useMediaQuery
- * @description - Hook that manages a media query
- * @category Browser
- *
- * @browserapi window.matchMedia https://developer.mozilla.org/en-US/docs/Web/API/Window/matchMedia
- *
- * @param {string} query The media query string
- * @returns {boolean} A boolean indicating if the media query matches
- *
- * @example
- * const matches = useMediaQuery('(max-width: 768px)');
- */
-declare const useMediaQuery: (query: string) => boolean;
-
-declare global {
-    interface Performance {
-        memory: {
-            readonly jsHeapSizeLimit: number;
-            readonly totalJSHeapSize: number;
-            readonly usedJSHeapSize: number;
-        };
-    }
-}
-/** The use memory return type */
-interface UseMemoryReturn {
-    /** The memory supported status */
-    supported: boolean;
-    /** The current memory usage */
-    value: Performance['memory'];
-}
-/**
- * @name useMemory
- * @description - Hook that gives you current memory usage
- * @category Browser
- *
- * @browserapi performance.memory https://developer.mozilla.org/en-US/docs/Web/API/Performance/memory
- *
- * @returns {UseMemoryReturn} An object containing the current memory usage
- *
- * @example
- * const { supported, value } = useMemory();
- */
-declare const useMemory: () => UseMemoryReturn;
-
-/**
- * @name useMount
- * @description - Hook that executes a callback when the component mounts
- * @category Lifecycle
- *
- * @param {EffectCallback} effect The callback to execute
- *
- * @example
- * useMount(() => console.log('This effect runs on the initial render'));
- */
-declare const useMount: (effect: EffectCallback) => void;
-
-/** The use mouse return type */
-interface UseMouseReturn {
-    /** The current element */
-    element?: Element;
-    /** The current element position x */
-    elementPositionX: number;
-    /** The current element position y */
-    elementPositionY: number;
-    /** The current element x position */
-    elementX: number;
-    /** The current element y position */
-    elementY: number;
-    /** The current mouse x position */
-    x: number;
-    /** The current mouse y position */
-    y: number;
-}
-interface UseMouse {
-    (target: HookTarget$1): UseMouseReturn;
-    <Target extends Element>(target?: never): UseMouseReturn & {
-        ref: StateRef<Target>;
-    };
-}
-/**
- * @name useMouse
- * @description - Hook that manages a mouse position
- * @category Sensors
- *
- * @overload
- * @param {HookTarget} target The target element to manage the mouse position for
- * @returns {UseMouseReturn} An object with the current mouse position
- *
- * @example
- * const { x, y, elementX, elementY, elementPositionX, elementPositionY } = useMouse(ref);
- *
- * @overload
- * @template Target The target element
- * @returns {UseMouseReturn & { ref: StateRef<Target> }} An object with the current mouse position and a ref
- *
- * @example
- * const { ref, x, y, elementX, elementY, elementPositionX, elementPositionY } = useMouse();
- */
-declare const useMouse: UseMouse;
-
-interface UseMutationOptions<Data> {
-    retry?: ((failureCount: number, error: Error) => boolean) | boolean | number;
-    retryDelay?: ((retry: number, error: Error) => number) | number;
-    onError?: (error: Error) => void;
-    onSuccess?: (data: Data) => void;
-}
-interface UseMutationReturn<Body, Data> {
-    data: Data | null;
-    error: Error | null;
-    isError: boolean;
-    isLoading: boolean;
-    isSuccess: boolean;
-    mutate: (body?: Body, options?: UseMutationOptions<Data>) => void;
-    mutateAsync: (body?: Body, options?: UseMutationOptions<Data>) => Promise<Data>;
-}
-interface RequestOptions<Data> extends UseMutationOptions<Data> {
-    attempt?: number;
-}
-/**
- * @name useMutation
- * @description - Hook that defines the logic when mutate data
- * @category Utilities
- *
- * @template Body The type of the body
- * @template Data The type of the data
- * @param {(body: Body) => Promise<Data>} callback The callback function to be invoked
- * @param {boolean | number} [options.retry] The retry count of requests
- * @param {(data: Data) => void} [options.onSuccess] The callback function to be invoked on success
- * @param {(error: Error) => void} [options.onError] The callback function to be invoked on error
- * @returns {UseMutationReturn<Data>} An object with the state of the mutation
- *
- * @example
- * const { mutate, mutateAsync, isLoading, isError, isSuccess, error, data } = useMutation((name) => Promise.resolve(name));
- */
-declare const useMutation: <Body, Data>(callback: (body: Body) => Promise<Data>, options?: UseMutationOptions<Data>) => UseMutationReturn<Body, Data>;
-
-/** The mutation observer target element type */
-type UseMutationObserverTarget = HookTarget$1;
-/** The mutation observer return type */
-interface UseMutationObserverReturn {
-    /** The mutation observer instance */
-    observer: MutationObserver;
-    /** The mutation observer entries */
-    stop: () => void;
-}
-/** The mutation observer options type */
-interface UseMutationObserverOptions extends MutationObserverInit {
-    /** The enabled state of the mutation observer */
-    enabled?: boolean;
-}
-interface UseMutationObserver {
-    (target: HookTarget$1, callback: MutationCallback, options?: UseMutationObserverOptions): UseMutationObserverReturn;
-    <Target extends Element>(callback: MutationCallback, options?: UseMutationObserverOptions, target?: never): UseMutationObserverReturn & {
-        ref: StateRef<Target>;
-    };
-}
-/**
- * @name useMutationObserver
- * @description - Hook that gives you mutation observer state
- * @category Browser
- *
- * @overload
- * @template Target The target element
- * @param {MutationCallback} callback The callback to execute when mutation is detected
- * @param {boolean} [options.enabled=true] The enabled state of the mutation observer
- * @param {boolean} [options.attributes] Set to true if mutations to target's attributes are to be observed
- * @param {boolean} [options.characterData] Set to true if mutations to target's data are to be observed
- * @param {boolean} [options.childList] Set to true if mutations to target's children are to be observed
- * @param {boolean} [options.subtree]  Set to true if mutations to not just target, but also target's descendants are to be observed
- * @param {boolean} [options.characterDataOldValue] Set to true if characterData is set to true or omitted and target's data before the mutation needs to be recorded
- * @param {boolean} [options.attributeOldValue]  Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted
- * @param {string[]} [options.attributeFilter] Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted
- * @returns {UseMutationObserverReturn & { ref: StateRef<Target> }} An object containing the mutation observer state
- *
- * @example
- * const { ref, observer, stop } = useMutationObserver(() => console.log('callback'))
- *
- * @overload
- * @param {HookTarget} target The target element to observe
- * @param {MutationCallback} callback The callback to execute when mutation is detected
- * @param {boolean} [options.enabled=true] The enabled state of the mutation observer
- * @param {boolean} [options.attributes] Set to true if mutations to target's attributes are to be observed
- * @param {boolean} [options.characterData] Set to true if mutations to target's data are to be observed
- * @param {boolean} [options.childList] Set to true if mutations to target's children are to be observed
- * @param {boolean} [options.subtree]  Set to true if mutations to not just target, but also target's descendants are to be observed
- * @param {boolean} [options.characterDataOldValue] Set to true if characterData is set to true or omitted and target's data before the mutation needs to be recorded
- * @param {boolean} [options.attributeOldValue]  Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted
- * @param {string[]} [options.attributeFilter] Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted
- * @returns {UseMutationObserverReturn} An object containing the mutation observer state
- *
- * @example
- * const { observer, stop } = useMutationObserver(ref, () => console.log('callback'))
- */
-declare const useMutationObserver: UseMutationObserver;
-
-interface Connection extends EventTarget {
-    readonly downlink: number;
-    readonly downlinkMax: number;
-    readonly effectiveType: '2g' | '3g' | '4g' | 'slow-2g';
-    readonly rtt: number;
-    readonly saveData: boolean;
-    onChange: (event: Event) => void;
-    readonly type: 'bluetooth' | 'cellular' | 'ethernet' | 'mixed' | 'none' | 'other' | 'unknown' | 'wifi' | 'wimax';
-}
-declare global {
-    interface Navigator {
-        readonly connection: Connection;
-        readonly mozConnection: Connection;
-        readonly webkitConnection: Connection;
-    }
-}
-/** The type of network connection */
-type ConnectionType = Connection['type'];
-/** The effective type of connection */
-type ConnectionEffectiveType = Connection['effectiveType'];
-/** The use network return type */
-interface UseNetworkReturn {
-    /** The estimated downlink speed in megabits per seconds */
-    downlink?: Connection['downlink'];
-    /** The maximum downlink speed, if available */
-    downlinkMax?: Connection['downlinkMax'];
-    /** The effective type of connection (e.g., '2g', '3g', '4g') */
-    effectiveType?: Connection['effectiveType'];
-    /** Indicates if the device is currently online */
-    online: boolean;
-    /** The estimated round-trip time in milliseconds */
-    rtt?: Connection['rtt'];
-    /** Indicates if the user has enabled data saving mode */
-    saveData?: Connection['saveData'];
-    /** The type of network connection (e.g., 'wifi', 'cellular') */
-    type?: Connection['type'];
-}
-declare const getConnection: () => Connection;
-/**
- * @name useNetwork
- * @description - Hook to track network status
- * @category Sensors
- *
- * @browserapi navigator.connection https://developer.mozilla.org/en-US/docs/Web/API/Navigator/connection
- *
- * @returns {UseNetworkReturn} An object containing the network status
- *
- * @example
- * const { online, downlink, downlinkMax, effectiveType, rtt, saveData, type } = useNetwork();
- */
-declare const useNetwork: () => UseNetworkReturn;
-
-/** The use offset pagination return type */
-interface UseOffsetPaginationOptions {
-    /** The initial page number */
-    initialPage?: number;
-    /** The number of items per page */
-    pageSize?: number;
-    /** The total number of items */
-    total?: number;
-    /** The callback function to be invoked when page changes */
-    onPageChange?: ({ page, pageSize }: {
-        page: number;
-        pageSize: number;
-    }) => void;
-    /** The callback function to be invoked when page count changes */
-    onPageCountChange?: ({ page, pageSize }: {
-        page: number;
-        pageSize: number;
-    }) => void;
-    /** The callback function to be invoked when page size changes */
-    onPageSizeChange?: ({ page, pageSize }: {
-        page: number;
-        pageSize: number;
-    }) => void;
-}
-/** The use offset pagination return type */
-interface UseOffsetPaginationReturn {
-    /** The number of items per page */
-    currentPageSize: number;
-    /** Whether the current page is the first page */
-    isFirstPage: boolean;
-    /** Whether the current page is the last page */
-    isLastPage: boolean;
-    /** The current page number */
-    page: number;
-    /** The total number of pages */
-    pageCount: number;
-    /** The callback function to go to the next page */
-    next: () => void;
-    /** The callback function to go to the previous page */
-    prev: () => void;
-    /** The callback function to set the current page */
-    set: (page: number) => void;
-}
-/**
- * @name useOffsetPagination
- * @description - Hook that defines the logic when pagination
- * @category Utilities
- *
- * @param {UseOffsetPaginationOptions} options - The options for the hook
- * @param {number} [options.total] - The total number of items
- * @param {number} [options.pageSize] - The number of items per page
- * @param {number} [options.initialPage] - The current page
- * @param {({ page, pageSize }: { page: number; pageSize: number }) => void} [options.onPageChange] - The callback function to be invoked when page changes
- * @param {({ page, pageSize }: { page: number; pageSize: number }) => void} [options.onPageCountChange] - The callback function to be invoked when page count changes
- * @param {({ page, pageSize }: { page: number; pageSize: number }) => void} [options.onPageSizeChange] - The callback function to be invoked when page size changes
- * @returns {UseOffsetPaginationReturn} - The state of the hook
- *
- * @example
- * const { currentPage, currentPageSize, pageCount, isFirstPage, isLastPage, prev, next } = useOffsetPagination({
- *  total: 100,
- *  pageSize: 10,
- *  page: 1,
- *  onPageChange: (page) => {},
- *  onPageCountChange: (pageCount) => {},
- *  onPageSizeChange: (pageSize) => {}
- * });
- */
-declare const useOffsetPagination: ({ total, pageSize, initialPage, onPageChange, onPageCountChange, onPageSizeChange }?: UseOffsetPaginationOptions) => UseOffsetPaginationReturn;
-
-/**
- * @name useOnline
- * @description - Hook that manages if the user is online
- * @category Sensors
- *
- * @browserapi navigator.onLine https://developer.mozilla.org/en-US/docs/Web/API/Navigator/onLine
- *
- * @returns {boolean} A boolean indicating if the user is online
- *
- * @example
- * const online = useOnline();
- */
-declare const useOnline: () => boolean;
-
-/** The operating system type */
-type OperatingSystem = 'android' | 'ios' | 'linux' | 'macos' | 'undetermined' | 'windows';
-declare const getOperatingSystem: () => OperatingSystem;
-/**
- * @name useOperatingSystem
- * @description - Hook that returns the operating system of the current browser
- * @category Browser
- *
- * @returns {OperatingSystem} The operating system
- *
- * @example
- * const operatingSystem = useOperatingSystem();
- */
-declare const useOperatingSystem: () => OperatingSystem;
-
-type UseOptimisticReturn<State> = [
-    State,
-    (optimisticValue: State, promise: Promise<any>) => void
-];
-/**
- * @name useOptimistic
- * @description - Hook that allows get optimistic value before its update
- * @category Utilities
- *
- * @template State The type of the state
- * @param {State} state The value to be returned initially and whenever no action is pending
- * @param {(currentState: State, optimisticValue: State) => State} update A pure function that takes the current state and the optimistic value passed to updateOptimistic and returns the resulting optimistic state
- * @returns {UseOptimisticReturn<State>} The resulting optimistic state, and the function to update it
- *
- * @example
- * const [optimisticValue, updateOptimistic] = useOptimistic<number>(count, (currentState, optimisticValue) => currentState + optimisticValue);
- */
-declare const useOptimistic: <State, OptimisticState = State>(externalState: State, update: (currentState: State, optimisticState: OptimisticState) => State) => readonly [State, (optimisticValue: OptimisticState, promise: Promise<any>) => Promise<any>];
-
-/** The use orientation return type */
-interface UseOrientationReturn {
-    /** The current screen orientation angle */
-    angle: number;
-    /** The screen orientation type */
-    type: OrientationType;
-}
-/**
- * @name useOrientation
- * @description - Hook that returns the current screen orientation
- * @category Browser
- *
- * @browserapi window.screen.orientation https://developer.mozilla.org/en-US/docs/Web/API/Screen/orientation
- *
- * @returns {UseOrientationReturn} An object containing the current screen orientation
- *
- * @example
- * const { angle, type } = useOrientation();
- */
-declare const useOrientation: () => UseOrientationReturn;
-
-declare global {
-    interface OTPOptions {
-        readonly transport: string[];
-    }
-    interface CredentialRequestOptions {
-        readonly otp: OTPOptions;
-    }
-    interface Credential {
-        readonly code: string;
-    }
-}
-type UseOtpCredentialCallback = (otp: Credential | null) => void;
-interface UseOtpCredentialParams {
-    onError: (error: any) => void;
-    onSuccess: (credential: Credential | null) => void;
-}
-interface UseOtpCredentialReturn {
-    abort: AbortController['abort'];
-    aborted: boolean;
-    supported: boolean;
-    get: () => Promise<Credential | null>;
-}
-interface UseOtpCredential {
-    (callback?: UseOtpCredentialCallback): UseOtpCredentialReturn;
-    (params?: UseOtpCredentialParams): UseOtpCredentialReturn;
-}
-/**
- * @name useOtpCredential
- * @description - Hook that creates an otp credential
- * @category Browser
- *
- * @browserapi navigator.credentials https://developer.mozilla.org/en-US/docs/Web/API/Navigator/credentials
- *
- * @overload
- * @param {UseOtpCredentialCallback} callback The callback function to be invoked
- * @returns {UseOtpCredentialReturn}
- *
- * @example
- * useOtpCredential((credential) => console.log(credential));
- *
- * @overload
- * @param {UseOtpCredentialCallback} params.onSuccess The callback function to be invoked on success
- * @param {UseOtpCredentialCallback} params.onError The callback function to be invoked on error
- * @returns {UseOtpCredentialReturn}
- *
- * @example
- * useOtpCredential({ onSuccess: (credential) => console.log(credential), onError: (error) => console.log(error) });
- */
-declare const useOtpCredential: UseOtpCredential;
-
-/**
- * @name usePageLeave
- * @description - Hook what calls given function when mouse leaves the page
- * @category Sensors
- *
- * @param {() => void} [callback] The callback function what calls then mouse leaves the page
- * @returns {boolean} A boolean which determines if the mouse left the page
- *
- * @example
- * const isLeft = usePageLeave(() => console.log('on leave'))
- */
-declare const usePageLeave: (callback?: () => void) => boolean;
-
-interface Point {
-    x: number;
-    y: number;
-}
-declare class Pointer implements Point {
-    x: number;
-    y: number;
-    constructor(x: number, y: number);
-    update(point: Point): void;
-    getDifferenceTo(point: Point): Pointer;
-    getDistanceTo(point: Point): number;
-    getAngleTo(point: Point): number;
-    equalsTo(point: Point): boolean;
-    moveByAngle(angle: number, distance: number): this;
-}
-declare class Paint {
-    pointer: Pointer;
-    brush: Pointer;
-    radius: number;
-    smooth: boolean;
-    points: Point[];
-    lines: {
-        points: Point[];
-        color: string;
-        radius: number;
-        opacity: number;
-    }[];
-    constructor({ x, y, radius, smooth }: {
-        x: number;
-        y: number;
-        radius: number;
-        smooth: boolean;
-    });
-    getBrushCoordinates(): {
-        x: number;
-        y: number;
-    };
-    getPointerCoordinates(): {
-        x: number;
-        y: number;
-    };
-    update(point: Point): boolean;
-}
-interface UsePaintOptions {
-    /** Brush color */
-    color?: string;
-    /** Initial lines */
-    initialLines?: Paint['lines'];
-    /** Brush opacity */
-    opacity?: number;
-    /** Brush radius */
-    radius?: number;
-    /** Smooth brush movement */
-    smooth?: boolean;
-    /** Callback when the mouse is down */
-    onMouseDown?: (event: MouseEvent, paint: Paint) => void;
-    /** Callback when the mouse is moved */
-    onMouseMove?: (event: MouseEvent, paint: Paint) => void;
-    /** Callback when the mouse is up */
-    onMouseUp?: (event: MouseEvent, paint: Paint) => void;
-}
-interface UsePaintReturn {
-    drawing: boolean;
-    lines: Paint['lines'];
-    clear: () => void;
-    draw: (points: Point[], color: string, opacity: number, radius: number) => void;
-    undo: () => void;
-}
-interface UsePaint {
-    (target: HookTarget$1, options?: UsePaintOptions): UsePaintReturn;
-    <Target extends HTMLCanvasElement>(options?: UsePaintOptions, target?: never): UsePaintReturn & {
-        ref: StateRef<Target>;
-    };
-}
-/**
- * @name usePaint
- * @description - Hook that allows you to draw in a specific area
- * @category Browser
- *
- * @overload
- * @param {HookTarget} target The target element to be painted
- * @param {UsePaintOptions} [options] The options to be used
- * @returns {UsePaintReturn} An object containing the current pencil options and functions to interact with the paint
- *
- * @example
- * const drawing = usePaint(canvasRef);
- *
- * @overload
- * @param {UsePaintOptions} [options] The options to be used
- * @returns {UsePaintReturn & { ref: StateRef<HTMLCanvasElement> }} An object containing the current pencil options and functions to interact with the paint
- *
- * @example
- * const { ref, drawing } = usePaint();
- */
-declare const usePaint: UsePaint;
-
-/** The use parallax value type */
-interface UseParallaxValue {
-    /** Roll value. Scaled to `-0.5 ~ 0.5` */
-    roll: number;
-    /** Sensor source, can be `mouse` or `deviceOrientation` */
-    source: 'deviceOrientation' | 'mouse';
-    /** Tilt value. Scaled to `-0.5 ~ 0.5` */
-    tilt: number;
-}
-/** The use parallax options type */
-interface UseParallaxOptions {
-    /** Device orientation roll adjust function */
-    deviceOrientationRollAdjust?: (value: number) => number;
-    /** Device orientation tilt adjust function */
-    deviceOrientationTiltAdjust?: (value: number) => number;
-    /** Mouse roll adjust function */
-    mouseRollAdjust?: (value: number) => number;
-    /** Mouse tilt adjust function */
-    mouseTiltAdjust?: (value: number) => number;
-}
-interface UseParallaxReturn {
-    value: UseParallaxValue;
-}
-interface UseParallax {
-    (target: HookTarget$1, options?: UseParallaxOptions): UseParallaxReturn;
-    <Target extends Element>(options?: UseParallaxOptions, target?: never): UseParallaxReturn & {
-        ref: StateRef<Target>;
-    };
-}
-/**
- * @name useParallax
- * @description - Hook to help create parallax effect
- * @category Sensors
- *
- * @overload
- * @param {HookTarget} target The target element for the parallax effect
- * @param {UseParallaxOptions} options The options for the parallax effect
- * @returns {UseParallaxReturn} An object of parallax values
- *
- * @example
- * const { value } = useParallax(ref);
- *
- * @overload
- * @template Target The target element for the parallax effect
- * @param {UseParallaxOptions} options The options for the parallax effect
- * @returns {UseParallaxReturn & { ref: StateRef<Target> }} An object of parallax values
- *
- * @example
- * const { ref, value } = useParallax();
- */
-declare const useParallax: UseParallax;
-
-/** The use performance observer options type */
-type UsePerformanceObserverOptions = PerformanceObserverInit & {
-    /** Whether to start the observer immediately */
-    immediate?: boolean;
-};
-/**
- * @name usePerformanceObserver
- * @description - Hook that allows you to observe performance entries
- * @category Sensors
- *
- * @browserapi PerformanceObserver https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver
- *
- * @param {UsePerformanceObserverOptions} options The options for the performance observer
- * @param {PerformanceObserverCallback} callback The function to handle performance entries
- * @returns {object} An object containing the observer's support status and methods to start and stop the observer
- *
- * @example
- * const { supported, entries, start, stop } = usePerformanceObserver();
- */
-declare const usePerformanceObserver: (options: UsePerformanceObserverOptions, callback?: PerformanceObserverCallback) => {
-    supported: boolean;
-    entries: PerformanceEntry[];
-    start: () => void;
-    stop: () => void;
-};
-
-/** The permission name */
-type UsePermissionName = 'accelerometer' | 'accessibility-events' | 'ambient-light-sensor' | 'background-sync' | 'camera' | 'clipboard-read' | 'clipboard-write' | 'gyroscope' | 'magnetometer' | 'microphone' | 'notifications' | 'payment-handler' | 'persistent-storage' | 'push' | 'speaker' | PermissionName;
-/** The use permission options type */
-interface UsePermissionOptions {
-    /** Whether the permission is enabled */
-    enabled: boolean;
-}
-/** The use permission return type */
-interface UsePermissionReturn {
-    /** The permission state */
-    state: PermissionState;
-    /** The permission supported status */
-    supported: boolean;
-    /** The permission query function */
-    query: () => Promise<PermissionState>;
-}
-/**
- *  @name usePermission
- *  @description - Hook that gives you the state of permission
- *  @category Browser
- *
- *  @browserapi navigator.permissions https://developer.mozilla.org/en-US/docs/Web/API/Navigator/permissions
- *
- *  @param {UsePermissionName} permissionDescriptorName - The permission name
- *  @param {boolean} [options.enabled=true] - Whether the permission is enabled
- *  @returns {UsePermissionReturn} An object containing the state and the supported status
- *
- *  @example
- *  const { state, supported, query } = usePermission('microphone');
- */
-declare const usePermission: (permissionDescriptorName: UsePermissionName, options?: UsePermissionOptions) => {
-    state: PermissionState;
-    supported: boolean;
-    query: () => Promise<PermissionState>;
-};
-
-/** The use pointer lock return type */
-interface UsePointerLockReturn {
-    /** The pointer lock element */
-    element?: Element;
-    /** Whether the pointer lock is supported */
-    supported: boolean;
-    /** Lock the pointer lock */
-    lock: (event: MouseEvent$1) => void;
-    /** Unlock the pointer lock */
-    unlock: () => boolean;
-}
-/**
- * @name usePointerLock
- * @description - Hook that provides reactive pointer lock
- * @category Sensors
- *
- * @browserapi pointerLockElement https://developer.mozilla.org/en-US/docs/Web/API/Document/pointerLockElement
- *
- * @returns {UsePointerLockReturn} An object containing the pointer lock element and functions to interact with the pointer lock
- *
- * @example
- * const { supported, lock, unlock, element } = usePointerLock();
- */
-declare const usePointerLock: () => UsePointerLockReturn;
-
-type UsePostMessageReturn<Message> = (message: Message) => void;
-/**
- * @name usePostMessage
- * @description - Hook that allows you to receive messages from other origins
- * @category Browser
- *
- * @overload
- * @template Message The message data type
- * @param {string | string[]} origin The origin of the message
- * @param {(message: Message) => Message} callback callback to get received message
- * @returns {(message: Message) => void} An object containing the current message
- *
- * @example
- * const postMessage = usePostMessage();
- */
-declare const usePostMessage: <Message>(origin: string | "*" | string[], callback: (message: Message, event: MessageEvent<Message>) => void) => UsePostMessageReturn<Message>;
-
-/** The use preferred color scheme return type */
-type UsePreferredColorSchemeReturn = 'dark' | 'light' | 'no-preference';
-/**
- * @name usePreferredColorScheme
- * @description - Hook that returns user preferred color scheme
- * @category Browser
- *
- * @returns {UsePreferredColorSchemeReturn} String of preferred color scheme
- *
- * @example
- * const colorScheme = usePreferredColorScheme();
- */
-declare const usePreferredColorScheme: () => UsePreferredColorSchemeReturn;
-
-/** The use preferred contrast return type */
-type UsePreferredContrastReturn = 'custom' | 'less' | 'more' | 'no-preference';
-/**
- * @name usePreferredContrast
- * @description - Hook that returns the contrast preference
- * @category Browser
- *
- * @returns {UsePreferredContrastReturn} The contrast preference
- *
- * @example
- * const contrast = usePreferredContrast();
- */
-declare const usePreferredContrast: () => UsePreferredContrastReturn;
-
-/**
- * @name usePreferredDark
- * @description - Hook that returns if the user prefers dark mode
- * @category Browser
- *
- * @example
- * const isDark = usePreferredDark();
- */
-declare const usePreferredDark: () => boolean;
-
-/**
- * @name usePreferredLanguages
- * @description Hook that returns a browser preferred languages from navigator
- * @category Browser
- *
- * @browserapi navigator.languages https://developer.mozilla.org/en-US/docs/Web/API/Navigator/languages
- *
- * @returns {readonly string[]} An array of strings representing the user's preferred languages
- *
- * @example
- * const languages = usePreferredLanguages();
- */
-declare const usePreferredLanguages: () => readonly string[];
-
-/** The use preferred reduced motion return type */
-type UsePreferredReducedMotionReturn = 'no-preference' | 'reduce';
-/**
- * @name usePreferredReducedMotion
- * @description - Hook that returns the reduced motion preference
- * @category Browser
- *
- * @returns {UsePreferredReducedMotionReturn} The reduced motion preference
- *
- * @example
- * const reduced = usePreferredReducedMotion();
- */
-declare const usePreferredReducedMotion: () => UsePreferredReducedMotionReturn;
-
-interface UsePreviousOptions<Value> {
-    equality: (a: Value, b: Value) => boolean;
-}
-/**
- * @name usePrevious
- * @description - Hook that returns the previous value
- * @category Utilities
- *
- * @template Value The type of the value
- * @param {Value} value The value to get the previous value
- * @param {(a: Value, b: Value) => boolean} [options.equality] The custom equality function to determine if the value has changed
- * @returns {Value} The previous value
- *
- * @example
- * const prevValue = usePrevious(value);
- */
-declare const usePrevious: <Value>(value: Value, options?: UsePreviousOptions<Value>) => Value | undefined;
-
-/** The use queue return type */
-interface UseQueueReturn<Value> {
-    /** Get the first element of the queue */
-    first: Value;
-    /** Get the last element of the queue */
-    last: Value;
-    /** The current queue */
-    queue: Value[];
-    /** Get the size of the queue */
-    size: number;
-    /** Add an element to the queue */
-    add: (element: Value) => void;
-    /** Clear the queue */
-    clear: () => void;
-    /** Remove an element from the queue */
-    remove: () => Value;
-}
-/**
- * @name useQueue
- * @description - Hook that manages a queue
- * @category Utilities
- *
- * @template Value The type of the value
- * @param {Value[]} [initialValue=[]] The initial value of the queue
- * @returns {UseQueueReturn} An object containing the current queue and functions to interact with the queue
- *
- * @example
- * const { queue, add, remove, clear, first, last, size } = useQueue([1, 2, 3]);
- */
-declare const useQueue: <Value>(initialValue?: Value[]) => UseQueueReturn<Value>;
-
-interface UseRafParams {
-    /** The delta between each frame in milliseconds */
-    delta: number;
-    /** The timestamp of the current frame in milliseconds */
-    timestamp: DOMHighResTimeStamp;
-}
-type UseRafCallback = (params: UseRafParams) => void;
-interface UseRafOptions {
-    /** The delay between each frame in milliseconds */
-    delay?: number;
-    /** Whether the callback should be enabled */
-    enabled?: boolean;
-}
-interface UseRafReturn {
-    /** Whether the callback is active */
-    active: boolean;
-    /** Function to pause the callback */
-    pause: () => void;
-    /** Function to resume the callback */
-    resume: () => void;
-}
-/**
- * @name useRaf
- * @description - Hook that defines the logic for raf callback
- * @category Utilities
- *
- * @browserapi requestAnimationFrame https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame
- *
- * @param {UseRafCallback} callback The callback to execute
- * @param {number} [options.delay] The delay between each frame in milliseconds
- * @param {boolean} [options.enabled=true] Whether the callback should be enabled
- * @returns {UseRafCallbackReturn} An object of raf callback functions
- *
- * @example
- * useRaf(() => console.log('callback'));
- */
-declare const useRaf: (callback: UseRafCallback, options?: UseRafOptions) => UseRafReturn;
-
-type UseRafValueReturn<Value> = [Value, (value: Value) => void];
-/**
- * @name useRafValue
- * @description - Hook that returns the value and a function to set the value
- * @category Utilities
- *
- * @template Value The type of the value
- * @param {Value} initialValue The initial value
- * @returns {UseRafValueReturn<Value>} An array containing the value and a function to set the value
- *
- * @example
- * const [value, setValue] = useRafValue(initialValue);
- */
-declare const useRafValue: <Value>(initialValue: (() => Value) | Value) => readonly [Value, (value: Value) => void];
-
-/**
- * @name useRenderCount
- * @description - Hook returns count component render times
- * @category Lifecycle
- *
- * @returns {number} A number which determines how many times component renders
- *
- * @example
- * const renderCount = useRenderCount();
- */
-declare const useRenderCount: () => number;
-
-interface UseRenderInfoReturn {
-    component: string;
-    renders: number;
-    sinceLast: number;
-    timestamp: number | null;
-}
-/**
- * @name useRenderInfo
- * @description - Hook for getting information about component rerender
- * @category Lifecycle
- *
- * @param {string} [name='Unknown'] Component name
- * @param {boolean} [log=true] Toggle logging
- * @returns {UseRenderInfoReturn} An object containing rerender information
- *
- * @example
- * const rerenderInfo = useRenderInfo('Component');
- */
-declare const useRenderInfo: (name?: string, log?: boolean) => UseRenderInfoReturn;
-
-/** The use rerender return type */
-type UseRerenderReturn = () => void;
-/**
- * @name useRerender
- * @description - Hook that defines the logic to force rerender a component
- * @category Lifecycle
- *
- * @returns {UseRerenderReturn} The rerender function
- *
- * @example
- * const rerender = useRerender();
- */
-declare const useRerender: () => UseRerenderReturn;
-
-/** The resize observer options type */
-interface UseResizeObserverOptions extends ResizeObserverOptions {
-    /** The enabled state */
-    enabled?: boolean;
-    /** The resize observer callback */
-    onChange?: (entries: ResizeObserverEntry[], observer: ResizeObserver) => void;
-}
-/** The resize observer return type */
-interface UseResizeObserverReturn {
-    /** The resize observer entries */
-    entries: ResizeObserverEntry[];
-}
-interface UseResizeObserver {
-    (target: HookTarget$1, options?: UseResizeObserverOptions): UseResizeObserverReturn;
-    <Target extends Element>(options?: UseResizeObserverOptions, target?: never): UseResizeObserverReturn & {
-        ref: StateRef<Target>;
-    };
-}
-/**
- *  @name useResizeObserver
- *  @description - Hook that gives you resize observer state
- *  @category Browser
- *
- *  @browserapi ResizeObserver https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
- *
- *  @overload
- *  @template Target The target element
- *  @param {boolean} [options.enabled=true] The IntersectionObserver options
- *  @param {boolean} [options.box] The IntersectionObserver options
- *  @param {(entries: ResizeObserverEntry[], observer: ResizeObserver) => void} [options.onChange] The callback to execute when resize is detected
- *  @returns {UseResizeObserverReturn & { ref: StateRef<Target> }} An object containing the resize observer state
- *
- *  @example
- *  const { ref, entries } = useResizeObserver();
- *
- *  @overload
- *  @template Target The target element
- *  @param {HookTarget} target The target element to observe
- *  @param {boolean} [options.enabled=true] The IntersectionObserver options
- *  @param {boolean} [options.box] The IntersectionObserver options
- *  @param {(entries: ResizeObserverEntry[], observer: ResizeObserver) => void} [options.onChange] The callback to execute when resize is detected
- *  @returns {UseResizeObserverReturn} An object containing the resize observer state
- *
- *  @example
- *  const { entries } = useResizeObserver(ref);
- */
-declare const useResizeObserver: UseResizeObserver;
-
-declare global {
-    interface ScreenOrientation {
-        lock: (orientation: OrientationLockType) => Promise<void>;
-    }
-}
-interface UseScreenOrientationValue {
-    /** The current angle */
-    angle: number;
-    /** The current orientation type */
-    orientationType: OrientationType;
-}
-type OrientationLockType = 'any' | 'landscape-primary' | 'landscape-secondary' | 'landscape' | 'natural' | 'portrait-primary' | 'portrait-secondary' | 'portrait';
-interface useScreenOrientationReturn {
-    /** Whether the screen orientation is supported */
-    supported: boolean;
-    /** The current screen orientation value */
-    value: UseScreenOrientationValue;
-    /** Lock the screen orientation */
-    lock: (orientation: OrientationLockType) => void;
-    /** Unlock the screen orientation */
-    unlock: () => void;
-}
-/**
- * @name useScreenOrientation
- * @description - Hook that provides the current screen orientation
- * @category Sensors
- *
- * @browserapi screen.orientation https://developer.mozilla.org/en-US/docs/Web/API/Screen/orientation
- *
- * @returns {useScreenOrientationReturn} The current screen orientation
- *
- * @example
- * const { supported, value, lock, unlock } = useScreenOrientation();
- */
-declare const useScreenOrientation: () => useScreenOrientationReturn;
-
-/** The use script status */
-type UseScriptStatus = 'error' | 'loading' | 'ready' | 'unknown';
-declare const SCRIPT_STATUS_ATTRIBUTE_NAME = "script-status";
-/** The use script options extends from attributes script tag */
-interface UseScriptOptions extends ComponentProps<'script'> {
-    /** Whether to remove the script on unmount */
-    removeOnUnmount?: boolean;
-}
-/**
- * @name useScript
- * @description - Hook that manages a script with onLoad, onError, and removeOnUnmount functionalities
- * @category Browser
- *
- * @param {string} src The source of the script
- * @param {UseScriptOptions} [options] The options of the script extends from attributes script tag
- * @param {boolean} [options.removeOnUnmount=true] Whether to remove the script on unmount
- * @param {boolean} [options.async=true] Whether to load the script asynchronously
- * @returns {UseScriptStatus} The status of the script
- *
- * @example
- * const status = useScript('https://example.com/script.js');
- */
-declare const useScript: (src: string, options?: UseScriptOptions) => UseScriptStatus;
-
-interface UseScrollOptions {
-    /** The on scroll callback */
-    onScroll?: (params: UseScrollCallbackParams, event: Event) => void;
-    /** The on end scroll callback */
-    onStop?: (event: Event) => void;
-    /** Offset arrived states by x pixels. */
-    offset?: {
-        left?: number;
-        right?: number;
-        top?: number;
-        bottom?: number;
-    };
-}
-interface UseScrollCallbackParams {
-    /** The element x position */
-    x: number;
-    /** The element y position */
-    y: number;
-    /** State of scroll arrived */
-    arrived: {
-        left: boolean;
-        right: boolean;
-        top: boolean;
-        bottom: boolean;
-    };
-    /** State of scroll direction */
-    directions: {
-        left: boolean;
-        right: boolean;
-        top: boolean;
-        bottom: boolean;
-    };
-}
-interface UseScroll {
-    (target: HookTarget$1, callback?: (params: UseScrollCallbackParams, event: Event) => void): boolean;
-    (target: HookTarget$1, options?: UseScrollOptions): boolean;
-    <Target extends Element>(callback?: (params: UseScrollCallbackParams, event: Event) => void, target?: never): {
-        ref: StateRef<Target>;
-        scrolling: boolean;
-    };
-    <Target extends Element>(options?: UseScrollOptions, target?: never): {
-        ref: StateRef<Target>;
-        scrolling: boolean;
-    };
-}
-/**
- * @name useScroll
- * @description - Hook that allows you to control scroll a element
- * @category Sensors
- *
- * @overload
- * @template Target The target element
- * @param {ScrollBehavior} [options.behavior=auto] The behavior of scrolling
- * @param {number} [options.offset.left=0] The left offset for arrived states
- * @param {number} [options.offset.right=0]  The right offset for arrived states
- * @param {number} [options.offset.top=0] The top offset for arrived states
- * @param {number} [options.offset.bottom=0] The bottom offset for arrived states
- * @param {(params: UseScrollCallbackParams, event: Event) => void} [options.onScroll] The callback function to be invoked on scroll
- * @param {(event: Event) => void} [options.onStop] The callback function to be invoked on scroll end
- * @returns {boolean} The state of scrolling
- *
- * @example
- * const scrolling = useScroll(ref, options);
- *
- * @overload
- * @template Target The target element
- * @param {(params: UseScrollCallbackParams, event: Event) => void} [callback] The callback function to be invoked on scroll
- * @returns {boolean} The state of scrolling
- *
- * @example
- * const scrolling = useScroll(ref, () => console.log('callback'));
- *
- * @overload
- * @template Target The target element
- * @param {Target} target The target element to scroll
- * @param {ScrollBehavior} [options.behavior=auto] The behavior of scrolling
- * @param {number} [options.offset.left=0] The left offset for arrived states
- * @param {number} [options.offset.right=0]  The right offset for arrived states
- * @param {number} [options.offset.top=0] The top offset for arrived states
- * @param {number} [options.offset.bottom=0] The bottom offset for arrived states
- * @param {(params: UseScrollCallbackParams, event: Event) => void} [options.onScroll] The callback function to be invoked on scroll
- * @param {(event: Event) => void} [options.onStop] The callback function to be invoked on scroll end
- * @returns {[StateRef<Target>, boolean]} The state of scrolling
- *
- * @example
- * const { ref, scrolling } = useScroll(options);
- *
- * @overload
- * @template Target The target element
- * @param {Target} target The target element to scroll
- * @param {(params: UseScrollCallbackParams, event: Event) => void} [callback] The callback function to be invoked on scroll
- * @returns {[StateRef<Target>, boolean]} The state of scrolling
- *
- * @example
- * const { ref, scrolling } = useScroll(() => console.log('callback'));
- */
-declare const useScroll: UseScroll;
-
-/** The scroll into view options type */
-interface UseScrollIntoViewOptions extends ScrollIntoViewOptions {
-    /** Whether to enable the scroll into view */
-    enabled?: boolean;
-}
-/** The scroll into view return type */
-interface UseScrollIntoViewReturn {
-    /** Function to scroll element into view */
-    trigger: (params?: {
-        behavior?: ScrollBehavior;
-        block?: ScrollLogicalPosition;
-        inline?: ScrollLogicalPosition;
-    }) => void;
-}
-interface UseScrollIntoView {
-    <Target extends Element>(options?: UseScrollIntoViewOptions, target?: never): UseScrollIntoViewReturn & {
-        ref: StateRef<Target>;
-    };
-    (target: HookTarget$1, options?: UseScrollIntoViewOptions): UseScrollIntoViewReturn;
-}
-/**
- * @name useScrollIntoView
- * @description - Hook that provides functionality to scroll an element into view
- * @category Sensors
- *
- * @overload
- * @param {HookTarget} target The target element to scroll into view
- * @param {ScrollBehavior} [options.behavior='smooth'] The scrolling behavior
- * @param {ScrollLogicalPosition} [options.block='start'] The vertical alignment
- * @param {ScrollLogicalPosition} [options.inline='nearest'] The horizontal alignment
- * @returns {UseScrollIntoViewReturn} Object containing scroll function
- *
- * @example
- * const { trigger } = useScrollIntoView(ref);
- *
- * @overload
- * @template Target The target element
- * @param {ScrollBehavior} [options.behavior='smooth'] The scrolling behavior
- * @param {ScrollLogicalPosition} [options.block='start'] The vertical alignment
- * @param {ScrollLogicalPosition} [options.inline='nearest'] The horizontal alignment
- * @returns {UseScrollIntoViewReturn & { ref: StateRef<Target> }} Object containing scroll function and ref
- *
- * @example
- * const { ref, trigger } = useScrollIntoView<HTMLDivElement>();
- */
-declare const useScrollIntoView: UseScrollIntoView;
-
-/** The use scroll to options type */
-interface UseScrollToOptions {
-    /** The scrolling behavior */
-    behavior?: ScrollBehavior;
-    /** Whether to enable the scroll to */
-    enabled?: boolean;
-    /** The horizontal position to scroll to */
-    x: number;
-    /** The vertical position to scroll to */
-    y: number;
-}
-/** The use scroll to return type */
-interface UseScrollToReturn {
-    /** The state of scrolling */
-    trigger: (params?: {
-        x: number;
-        y: number;
-        behavior?: ScrollBehavior;
-    }) => void;
-}
-interface UseScrollTo {
-    <Target extends Element>(options?: UseScrollToOptions, target?: never): UseScrollToReturn & {
-        ref: StateRef<Target>;
-    };
-    (target: HookTarget$1, options?: UseScrollToOptions): UseScrollToReturn;
-}
-/**
- * @name useScrollTo
- * @description - Hook for scrolling to a specific element
- * @category Sensors
- *
- * @overload
- * @param {HookTarget} target The target element for scrolling to
- * @param {UseScrollToOptions} [options] The scroll options
- * @returns {UseScrollToReturn} The scroll trigger function
- *
- * @example
- * const trigger = useScrollTo(ref, options);
- *
- * @overload
- * @template Target The target element
- * @param {UseScrollToOptions} [options] The scroll options
- * @returns {UseScrollToReturn & { ref: StateRef<Target> }} The scroll trigger function and ref
- *
- * @example
- * const { ref, trigger } = useScrollTo(options);
- */
-declare const useScrollTo: UseScrollTo;
-
-/**
- * @name useSessionStorage
- * @description - Hook that manages session storage value
- * @category Browser
- *
- * @browserapi sessionStorage https://developer.mozilla.org/en-US/docs/Web/API/Window/sessionStorage
- *
- * @template Value The type of the value
- * @param {string} key The key of the storage
- * @param {UseStorageInitialValue<Value>} [initialValue] The initial value of the storage
- * @param {UseStorageOptions<Value>} [options] The options of the storage
- *
- * @example
- * const { value, set, remove } = useSessionStorage('key', 'value');
- */
-declare const useSessionStorage: <Value>(key: string, initialValue?: UseStorageInitialValue<Value>, options?: Omit<UseStorageOptions<Value>, "initialValue" | "storage">) => {
-    value: Value | undefined;
-    set: (value: Value) => void;
-    remove: () => void;
-};
-
-/** The use set return type */
-interface UseSetReturn<Value> {
-    /** The size of the set */
-    size: number;
-    /** The current set */
-    value: Set<Value>;
-    /** Function to add a value to the set */
-    add: (value: Value) => void;
-    /** Function to clear the set */
-    clear: () => void;
-    /** Function to get the symmetric difference of two sets */
-    difference: (other: Set<Value>) => void;
-    /** Function to check if a value exists in the set */
-    has: (value: Value) => boolean;
-    /** Function to get the difference of two sets */
-    intersection: (other: Set<Value>) => void;
-    /** Function to remove a value from the set */
-    remove: (value: Value) => void;
-    /** Function to toggle a value in the set */
-    reset: () => void;
-    /** Function to get the symmetric difference of two sets */
-    symmetricDifference: (other: Set<Value>) => void;
-    /** Function to toggle a value in the set */
-    toggle: (value: Value) => void;
-    /** Function to get the union of two sets */
-    union: (other: Set<Value>) => void;
-}
-/**
- * @name useSet
- * @description - Hook that manages a set structure
- * @category Utilities
- *
- * @template Value The type of the value
- * @param {Value[]} [values] The initial array of the set
- * @returns {UseSetReturn<Value>} An object containing the current set and functions to interact with the set
- *
- * @example
- * const { value, add, remove, clear, reset, toggle, union, intersection, difference, symmetricDifference, size, has } = useSet([1, 2, 3]);
- */
-declare const useSet: <Value>(values?: Value[]) => UseSetReturn<Value>;
-
-/** The use share options type */
-interface UseShareParams {
-    /** Array of files to be shared */
-    files?: File[];
-    /** Text content to be shared */
-    text?: string;
-    /** Title of the content being shared */
-    title?: string;
-    /** URL link to be shared */
-    url?: string;
-}
-/** The use share return type */
-interface UseShareReturn {
-    /** Whether the Web Share API is supported in the current environment */
-    supported: boolean;
-    /** Function to trigger the native share dialog */
-    share: (shareParams: ShareData) => Promise<void>;
-}
-/**
- * @name useShare
- * @description - Hook that utilizes the share api
- * @category Browser
- *
- * @param {UseShareParams} [params] The use share options
- * @returns {UseShareReturn}
- *
- * @example
- * const { share, supported } = useShare();
- */
-declare const useShare: (params?: UseShareParams) => {
-    share: (shareParams: ShareData) => Promise<void>;
-    supported: boolean;
-};
-
-/** The use state history hook return type */
-interface UseStateHistoryReturn<Value> {
-    /** All history values */
-    history: Value[];
-    /** Current index in history */
-    index: number;
-    /** Current value */
-    value: Value;
-    /** Go back specified number of steps in history (default: 1) */
-    back: (steps?: number) => void;
-    /** Go forward specified number of steps in history (default: 1) */
-    forward: (steps?: number) => void;
-    /** Reset history to initial state */
-    reset: () => void;
-    /** Set a new value */
-    set: (value: Value) => void;
-    /** Undo the last change */
-    undo: () => void;
-}
-/**
- * @name useStateHistory
- * @description - Hook that manages state with history functionality
- * @category Utilities
- *
- * @param {Value} initialValue - The initial value to start the history with
- * @param {number} [maxSize=10] - Maximum number of history entries to keep
- * @returns {UseStateHistoryReturn<Value>} Object containing current value, history array and control methods
- *
- * @example
- * const { value, history, index, set, back, forward, reset, undo } = useStateHistory(0);
- */
-declare const useStateHistory: <Value>(initialValue: Value, maxSize?: number) => UseStateHistoryReturn<Value>;
-
-/** The use step params type */
-interface UseStepParams {
-    /** Initial value for step */
-    initial: number;
-    /** Maximum value for step */
-    max: number;
-}
-/** The use step return type */
-interface UseStepReturn {
-    /** Counts of steps */
-    counts: number;
-    /** Current value of step */
-    currentStep: number;
-    /** Boolean value if current step is first */
-    isFirst: boolean;
-    /** Boolean value if current step is last */
-    isLast: boolean;
-    /** Go to back step */
-    back: () => void;
-    /** Go to next step */
-    next: () => void;
-    /** Reset current step to initial value */
-    reset: () => void;
-    /** Go to custom step */
-    set: (value: number | 'first' | 'last') => void;
-}
-/**
- * @name useStep
- * @description - Hook that create stepper
- * @category Utilities
- *
- * @overload
- * @param {number} max Maximum number of steps
- * @returns {UseStepReturn} An object contains variables and functions to change the step
- *
- * @example
- * const stepper = useStep(5);
- *
- * @overload
- * @param {number} params.max Maximum number of steps
- * @param {number} params.initial Initial value for step
- * @returns {UseStepReturn} An object contains variables and functions to change the step
- *
- * @example
- * const stepper = useStep({ initial: 2, max: 5 });
- */
-declare const useStep: (params: number | UseStepParams) => UseStepReturn;
-
-/** The use sticky return type */
-interface UseStickyReturn {
-    stuck: boolean;
-}
-/** The use sticky axis type */
-type UseStickyAxis = 'horizontal' | 'vertical';
-/** The use sticky options type */
-interface UseStickyOptions {
-    axis?: UseStickyAxis;
-    root?: HookTarget$1;
-}
-interface UseSticky {
-    (target: HookTarget$1, options?: UseStickyOptions): boolean;
-    <Target extends Element>(options?: UseStickyOptions, target?: never): {
-        ref: StateRef<Target>;
-    } & UseStickyReturn;
-}
-/**
- * @name UseSticky
- * @description - Hook that allows you to detect that your sticky component is stuck
- * @category Browser
- *
- * @overload
- * @param {HookTarget} target The target sticky element
- * @param {UseStickyAxis} [options.axis='vertical'] The axis of motion of the sticky component
- * @param {UseStickyRoot} [options.root=document] The element that contains your sticky component
- * @returns {UseStickyReturn} The state of the sticky
- *
- * @example
- * const stuck  = useSticky(ref);
- *
- * @overload
- * @param {UseStickyAxis} [options.axis='vertical'] The axis of motion of the sticky component
- * @param {UseStickyRoot} [options.root=document] The element that contains your sticky component
- * @returns {{ stickyRef: StateRef<Target> } & UseStickyReturn} The state of the sticky
- *
- * @example
- * const { stuck, ref } = useSticky();
- */
-declare const useSticky: UseSticky;
-
-/** The use stopwatch return type */
-interface UseStopwatchReturn {
-    /** The total count of the stopwatch */
-    count: number;
-    /** The day count of the stopwatch */
-    days: number;
-    /** The hour count of the stopwatch */
-    hours: number;
-    /** The minute count of the stopwatch */
-    minutes: number;
-    /** The over state of the stopwatch */
-    over: boolean;
-    /** The paused state of the stopwatch */
-    paused: boolean;
-    /** The second count of the stopwatch */
-    seconds: number;
-    /** The function to pause the stopwatch */
-    pause: () => void;
-    /** The function to reset the stopwatch */
-    reset: () => void;
-    /** The function to start the stopwatch */
-    start: () => void;
-    /** The function to toggle the stopwatch */
-    toggle: () => void;
-}
-/** The use stopwatch options */
-interface UseStopwatchOptions {
-    /** The enabled state of the timer */
-    enabled?: boolean;
-}
-interface UseStopwatch {
-    (initialTime?: number, options?: UseStopwatchOptions): UseStopwatchReturn;
-    (options?: UseStopwatchOptions & {
-        initialTime?: number;
-    }): UseStopwatchReturn;
-}
-/**
- * @name useStopwatch
- * @description - Hook that creates a stopwatch functionality
- * @category Time
- *
- * @overload
- * @param {number} [initialTime=0] The initial time of the timer
- * @param {boolean} [options.enabled=true] The enabled state of the timer
- * @returns {UseStopwatchReturn} An object containing the current time and functions to interact with the timer
- *
- * @example
- * const { seconds, minutes, start, pause, reset } = useStopwatch(1000, { enabled: false });
- *
- * @overload
- * @param {number} [options.initialTime=0] -The initial time of the timer
- * @param {boolean} [options.enabled=true] The enabled state of the timer
- * @returns {UseStopwatchReturn} An object containing the current time and functions to interact with the timer
- *
- * @example
- * const { seconds, minutes, start, pause, reset } = useStopwatch({ initialTime: 1000, enabled: false });
- */
-declare const useStopwatch: UseStopwatch;
-
-/** The use text direction value type */
-type UseTextDirectionValue = 'auto' | 'ltr' | 'rtl';
-/** The use text direction return type */
-interface UseTextDirectionReturn {
-    /** The current direction */
-    value: UseTextDirectionValue;
-    /*** The function to remove the direction */
-    remove: () => void;
-    /*** The function to set the direction */
-    set: (value: UseTextDirectionValue | null) => void;
-}
-interface UseTextDirection {
-    (target: HookTarget$1, initialValue?: UseTextDirectionValue): UseTextDirectionReturn;
-    <Target extends Element>(initialValue?: UseTextDirectionValue, target?: never): UseTextDirectionReturn & {
-        ref: StateRef<Target>;
-    };
-}
-/**
- * @name useTextDirection
- * @description - Hook that can get and set the direction of the element
- * @category Browser
- *
- * @overload
- * @param {HookTarget} target The target element to observe
- * @param {UseTextDirectionValue} [initialValue = 'ltr'] The initial direction of the element
- * @returns {UseTextDirectionReturn} An object containing the current text direction of the element
- *
- * @example
- * const { value, set, remove } = useTextDirection(ref);
- *
- * @overload
- * @template Target The target element type
- * @param {UseTextDirectionValue} [initialValue = 'ltr'] The initial direction of the element
- * @returns { { ref: StateRef<Target> } & UseTextDirectionReturn } An object containing the current text direction of the element
- *
- * @example
- * const { ref, value, set, remove } = useTextDirection();
- */
-declare const useTextDirection: UseTextDirection;
-
-declare const getRangesSelection: (selection: Selection) => Range[];
-/** The use text selection return type */
-interface UseTextSelectionReturn {
-    /** The current selection ranges */
-    ranges: Range[];
-    /** The current selection rects */
-    rects: DOMRect[];
-    /** The current selection */
-    selection: Selection | null;
-    /** The current selection text */
-    text: string;
-}
-/**
- * @name useTextSelection
- * @description - Hook that manages the text selection
- * @category Sensors
- *
- * @browserapi document.getSelection https://developer.mozilla.org/en-US/docs/Web/API/Document/getSelection
- *
- * @returns {UseTextSelectionReturn} An object containing the current text selection
- *
- * @example
- * const selection = useTextSelection();
- */
-declare const useTextSelection: () => UseTextSelectionReturn;
-
-/**
- * @name useThrottleCallback
- * @description - Hook that creates a throttled 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 throttle
- *
- * @example
- * const throttled = useThrottleCallback(() => console.log('callback'), 500);
- */
-declare const useThrottleCallback: <Params extends unknown[], Return>(callback: (...args: Params) => Return, delay: number) => (...args: Params) => void;
-
-/**
- * @name useThrottleValue
- * @description - Hook that creates a throttled value
- * @category Utilities
- *
- * @template Value The type of the value
- * @param {Value} value The value to be throttled
- * @param {number} delay The delay in milliseconds
- * @returns {Value} The throttled value
- *
- * @example
- * const throttledValue = useThrottleValue(value, 500);
- */
-declare const useThrottleValue: <Value>(value: Value, delay: number) => Value;
-
-interface UseTimeReturn {
-    day: number;
-    hours: number;
-    meridiemHours: {
-        value: number;
-        type: string;
-    };
-    minutes: number;
-    month: number;
-    seconds: number;
-    timestamp: number;
-    year: number;
-}
-/**
- * @name useTime
- * @description - Hook that gives you current time in different values
- * @category Time
- *
- * @returns {UseTimeReturn} An object containing the current time
- *
- * @example
- * const { seconds, minutes, hours, meridiemHours, day, month, year, timestamp } = useTime();
- */
-declare const useTime: () => UseTimeReturn;
-
-/** The use timeout return type */
-interface UseTimeoutReturn {
-    /**  Timeout is ready state value */
-    ready: boolean;
-    /** Function to clear timeout */
-    clear: () => void;
-}
-/**
- * @name useTimeout
- * @description - Hook that executes a callback function after a specified delay
- * @category Time
- *
- * @param {() => void} callback The function to be executed after the timeout
- * @param {number} delay The delay in milliseconds before the timeout executes the callback function
- * @returns {UseTimeoutReturn} An object with a `ready` boolean state value and a `clear` function to clear timeout
- *
- * @example
- * const { clear, ready } = useTimeout(() => {}, 5000);
- */
-declare function useTimeout(callback: () => void, delay: number): UseTimeoutReturn;
-
-type PositiveInteger<Value extends number> = `${Value}` extends `-${any}` | `${any}.${any}` ? never : Value;
-declare const getTimeFromSeconds: (timestamp: number) => {
-    seconds: number;
-    minutes: number;
-    hours: number;
-    days: number;
-};
-/** The use timer options type */
-interface UseTimerOptions {
-    /** Whether the timer should start automatically */
-    immediately?: boolean;
-    /** The function to be executed when the timer is expired */
-    onExpire?: () => void;
-    /** The function to be executed when the timer is started */
-    onStart?: () => void;
-    /** Callback function to be executed on each tick of the timer */
-    onTick?: (seconds: number) => void;
-}
-/** The use timer return type */
-interface UseTimerReturn {
-    /** flag to indicate if timer is active or not */
-    active: boolean;
-    /** The total count of the timer */
-    count: number;
-    /** The day count of the timer */
-    days: number;
-    /** The hour count of the timer */
-    hours: number;
-    /** The minute count of the timer */
-    minutes: number;
-    /** The second count of the timer */
-    seconds: number;
-    /** The function to clear the timer */
-    clear: () => void;
-    /** The function to decrease the timer */
-    decrease: (seconds: PositiveInteger<number>) => void;
-    /** The function to increase the timer */
-    increase: (seconds: PositiveInteger<number>) => void;
-    /** The function to pause the timer */
-    pause: () => void;
-    /** The function to restart the timer */
-    restart: (time: PositiveInteger<number>, immediately?: boolean) => void;
-    /** The function to resume the timer */
-    resume: () => void;
-    /** The function to start the timer */
-    start: () => void;
-    /** The function to toggle the timer */
-    toggle: () => void;
-}
-interface UseTimer {
-    (): UseTimerReturn;
-    (seconds: PositiveInteger<number>, callback: () => void): UseTimerReturn;
-    (seconds: PositiveInteger<number>, options?: UseTimerOptions): UseTimerReturn;
-}
-/**
- * @name useTimer
- * @description - Hook that creates a timer functionality
- * @category Time
- *
- * @overload
- * @returns {UseTimerReturn} An object containing the timer properties and functions
- *
- * @example
- * const { days, hours, minutes, seconds, toggle, pause, start, restart, resume, active, decrease, increase } = useTimer();
- *
- * @overload
- * @param {number} seconds The seconds value that define for how long the timer will be running
- * @param {() => void} callback The function to be executed once countdown timer is expired
- * @returns {UseTimerReturn} An object containing the timer properties and functions
- *
- * @example
- * const { days, hours, minutes, seconds, toggle, pause, start, restart, resume, active, decrease, increase } = useTimer(1000, () => console.log('ready'));
- *
- * @overload
- * @param {number} seconds The seconds value that define for how long the timer will be running
- * @param {boolean} [options.immediately=true] The flag to decide if timer should start automatically
- * @param {() => void} [options.onExpire] The function to be executed when the timer is expired
- * @param {(timestamp: number) => void} [options.onTick] The function to be executed on each tick of the timer
- * @returns {UseTimerReturn} An object containing the timer properties and functions
- *
- * @example
- * const { days, hours, minutes, seconds, toggle, pause, start, restart, resume, active, decrease, increase } = useTimer(1000);
- */
-declare const useTimer: UseTimer;
-
-/** The use toggle return type */
-type UseToggleReturn<Value> = readonly [Value, (value?: Value) => void];
-/**
- * @name useToggle
- * @description - Hook that create toggle
- * @category Utilities
- *
- * @template Value The type of the value
- * @param {Value[]} [values=[false, true]] The values to toggle
- *
- * @example
- * const [on, toggle] = useToggle();
- *
- * @example
- * const [value, toggle] = useToggle(['light', 'dark'] as const);
- */
-declare const useToggle: <Value = boolean>(values?: readonly Value[]) => readonly [Value, (value?: SetStateAction<Value>) => void];
-
-/**
- * @name useUnmount
- * @description - Hook that defines the logic when unmounting a component
- * @category Lifecycle
- *
- * @param {() => void} callback The callback function to be invoked on component unmount
- * @returns {void}
- *
- * @example
- * useUnmount(() => console.log('This effect runs on component unmount'));
- */
-declare const useUnmount: (callback: () => void) => void;
-
-/** The use vibrate pattern type */
-type UseVibratePattern = number | number[];
-/** The use vibrate return type */
-interface UseVibrateReturn {
-    /** The support indicator */
-    supported: boolean;
-    /** The vibrating indicator */
-    vibrating: boolean;
-    /** The pause function */
-    pause: () => void;
-    /** The resume function */
-    resume: () => void;
-    /** The start function */
-    start: (interval: number) => void;
-    /** The vibrate function */
-    trigger: (pattern?: UseVibratePattern) => void;
-}
-/**
- * @name useVibrate
- * @description - Hook that provides vibrate api
- * @category Browser
- *
- * @browserapi navigator.vibrate https://developer.mozilla.org/en-US/docs/Web/API/Navigator/vibrate
- *
- * @overload
- * @param {UseVibratePattern} options.pattern The pattern for vibration
- * @param {number} [options.interval=0] Time in milliseconds between vibrations
- * @returns {UseVibrateReturn} An object containing support indicator, start vibration and stop vibration functions
- *
- * @example
- * const { supported, active, vibrate, stop, pause, resume } = useVibrate(1000);
- */
-declare const useVibrate: (pattern: UseVibratePattern, interval?: number) => {
-    supported: boolean;
-    trigger: (internalPattern?: UseVibratePattern) => void;
-    stop: () => void;
-    active: boolean;
-    pause: () => void;
-    resume: (intervalInterval?: number) => void;
-};
-
-type UseWebSocketUrl = (() => string) | string;
-interface UseWebSocketOptions {
-    protocols?: Array<'soap' | 'wasm'>;
-    retry?: boolean | number;
-    onConnected?: (webSocket: WebSocket) => void;
-    onDisconnected?: (event: CloseEvent, webSocket: WebSocket) => void;
-    onError?: (event: Event, webSocket: WebSocket) => void;
-    onMessage?: (event: MessageEvent, webSocket: WebSocket) => void;
-}
-type UseWebSocketStatus = 'connected' | 'connecting' | 'disconnected' | 'failed';
-interface UseWebSocketReturn {
-    client?: WebSocket;
-    close: WebSocket['close'];
-    send: WebSocket['send'];
-    status: UseWebSocketStatus;
-    open: () => void;
-}
-/**
- * @name useWebSocket
- * @description - Hook that connects to a WebSocket server and handles incoming and outgoing messages
- * @category Browser
- *
- * @param {UseWebSocketUrl} url The URL of the WebSocket server
- * @param {(webSocket: WebSocket) => void} [options.onConnected] The callback function that is called when the WebSocket connection is established
- * @param {(event: CloseEvent, webSocket: WebSocket) => void} [options.onDisconnected] The callback function that is called when the WebSocket connection is closed
- * @param {(event: Event, webSocket: WebSocket) => void} [options.onError] The callback function that is called when an error occurs
- * @param {(event: MessageEvent, webSocket: WebSocket) => void} [options.onMessage] The callback function that is called when a message is received
- * @param {boolean | number} [options.retry] The number of times to retry the connection
- * @param {Array<'soap' | 'wasm'>} [options.protocols] The list of protocols to use
- * @returns {UseWebSocketReturn} An object with the status, close, send, open, and ws properties
- *
- * @example
- * const { status, close, send, open, client } = useWebSocket('url');
- */
-declare const useWebSocket: (url: UseWebSocketUrl, options?: UseWebSocketOptions) => UseWebSocketReturn;
-
-/**
- * @name useWindowEvent
- * @description - Hook attaches an event listener to the window object for the specified event
- * @category Browser
- *
- * @template Event Key of window event map.
- * @param {Event} event The event to listen for.
- * @param {(event: WindowEventMap[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
- * useWindowEvent('click', () => console.log('clicked'));
- */
-declare const useWindowEvent: <Event extends keyof WindowEventMap>(event: Event, listener: (this: Window, event: WindowEventMap[Event]) => any, options?: UseEventListenerOptions) => void;
-
-/**
- * @name useWindowFocus
- * @description - Hook that provides the current focus state of the window
- * @category Elements
- *
- * @returns {boolean} The current focus state of the window
- *
- * @example
- * const focused = useWindowFocus();
- */
-declare const useWindowFocus: () => boolean;
-
-interface ScrollPosition {
-    x: number;
-    y: number;
-}
-declare const scrollTo: ({ x, y, behavior }: Partial<ScrollPosition & ScrollOptions>) => void;
-/**
- * @name useWindowScroll
- * @description - Hook that manages the window scroll position
- * @category Browser
- *
- * @returns {UseWindowScrollReturn} An object containing the current window scroll position
- *
- * @example
- * const { value, scrollTo } = useWindowScroll();
- */
-declare const useWindowScroll: () => {
-    value: ScrollPosition;
-    scrollTo: ({ x, y, behavior }: Partial<ScrollPosition & ScrollOptions>) => void;
-};
-
-/** The use window size return type */
-interface UseWindowSizeParams {
-    /** Whether to include the scrollbar in the window size calculation */
-    includeScrollbar?: boolean;
-}
-/** The use window size return type */
-interface UseWindowSizeReturn {
-    /** The current window height */
-    height: number;
-    /** The current window width */
-    width: number;
-}
-/**
- * @name useWindowSize
- * @description - Hook that manages a window size
- * @category Elements
- *
- * @param {number} [params.initialWidth=Number.POSITIVE_INFINITY] The initial window width
- * @param {number} [params.initialHeight=Number.POSITIVE_INFINITY] The initial window height
- * @returns {UseWindowSizeReturn} An object containing the current window width and height
- *
- * @example
- * const { width, height } = useWindowSize();
- */
-declare const useWindowSize: (params?: UseWindowSizeParams) => {
-    width: number;
-    height: number;
-};
-
-interface WizardItem<WizardStepId> {
-    id: WizardStepId;
-    nodes?: WizardStepId[];
-}
-/**
- * @name useWizard
- * @description - Hook that manages a wizard
- * @category Utilities
- *
- * @param {WizardItem<WizardStepId>[]} map The map of the wizard
- * @param {WizardStepId} [initialStepId] The initial step id
- * @returns {UseWizardReturn<WizardStepId>} An object containing the current step id and functions to interact with the wizard
- *
- * @example
- * const { currentStepId, set, reset, back, history } = useWizard([
- *  { id: 'step1', nodes: ['step2', 'step3'] },
- *  { id: 'step2', nodes: ['step3'] },
- *  { id: 'step3', nodes: [] },
- * ])
- */
-declare const useWizard: <WizardStepId extends string>(map: WizardItem<WizardStepId>[], initialStepId?: WizardStepId) => {
-    currentStepId: WizardStepId;
-    set: (id: WizardStepId) => void;
-    reset: () => void;
-    back: () => void;
-    history: WizardStepId[];
-};
-
-declare const legacyCopyToClipboard: (value: string) => void;
-declare const copy: (value: string) => Promise<void>;
-
-declare function debounce<Params extends unknown[]>(callback: (...args: Params) => void, delay: number): (...args: Params) => void;
-
-declare const getDate: (now?: Date) => {
-    seconds: number;
-    minutes: number;
-    hours: number;
-    meridiemHours: {
-        value: number;
-        type: string;
-    };
-    day: number;
-    month: number;
-    year: number;
-    timestamp: number;
-};
-
-type Target = (() => Element) | string | Document | Element | Window;
-type HookTarget = RefObject<Element | null | undefined> | {
-    value: Target;
-    type: symbol;
-};
-declare const targetSymbol: unique symbol;
-declare const target: (target: Target) => {
-    value: Target;
-    type: symbol;
-};
-declare const getElement: (target: HookTarget) => Element | Window | Document | null | undefined;
-
-declare const getRetry: (retry: boolean | number) => number;
-
-declare const isTarget: (target: HookTarget) => boolean;
-
-declare const throttle: <Params extends any[]>(callback: (...args: Params) => void, delay: number) => ((...args: Params) => void);
-
-export { BREAKPOINTS_ANT_DESIGN, BREAKPOINTS_BOOTSTRAP_V5, BREAKPOINTS_MANTINE, BREAKPOINTS_MASTER_CSS, BREAKPOINTS_MATERIAL_UI, BREAKPOINTS_PRIME_FLEX, BREAKPOINTS_QUASAR_V2, BREAKPOINTS_SEMANTIC, BREAKPOINTS_TAILWIND, type BatteryManager, type Breakpoints, COOKIE_EVENT, type ColorSelectionOptions, type ColorSelectionResult, type Connection, type ConnectionEffectiveType, type ConnectionType, type EyeDropper, type EyeDropperConstructor, type HookTarget, type KeyboardEventHandler, type LongPressReactEvents, type OperatingSystem, type OrientationLockType, Paint, type Point, Pointer, type PositiveInteger, type RemoveCookieParams, type RequestOptions, SCRIPT_STATUS_ATTRIBUTE_NAME, STORAGE_EVENT, type ScrollPosition, type SetCookieParams, type StateRef, type Target, type UseAsyncReturn, type UseBatteryStateReturn, type UseBatteryValue, type UseBluetoothOptions, type UseBluetoothReturn, type UseBooleanReturn, type UseBreakpointsReturn, type UseBreakpointsStrategy, type UseClickOutside, type UseCookieInitialValue, type UseCookieOptions, type UseCookieReturn, type UseCopyParams, type UseCopyReturn, type UseCopyToClipboardParams, type UseCopyToClipboardReturn, type UseCounter, type UseCounterOptions, type UseCounterReturn, type UseCssVar, type UseCssVarReturn, type UseDeviceMotionParams, type UseDeviceMotionReturn, type UseDeviceOrientationReturn, type UseDeviceOrientationValue, type UseDevicePixelRatioReturn, type UseDisclosureOptions, type UseDisclosureReturn, type UseDisplayMedia, type UseDisplayMediaOptions, type UseDisplayMediaReturn, type UseDocumentTitleOptions, type UseDocumentTitleReturn, type UseElementSize, type UseElementSizeReturn, type UseElementSizeValue, type UseEventListener, type UseEventListenerOptions, type UseEventListenerReturn, type UseEyeDropperReturn, type UseFaviconReturn, type UseFieldParams, type UseFieldRegisterParams, type UseFieldReturn, type UseFileDialog, type UseFileDialogOptions, type UseFileDialogReturn, type UseFocus, type UseFocusOptions, type UseFocusReturn, type UseFullScreen, type UseFullScreenOptions, type UseFullScreenReturn, type UseGamepadStateReturn, type UseGeolocationParams, type UseGeolocationReturn, type UseHotkeys, type UseHotkeysHotkeys, type UseHotkeysKey, type UseHotkeysOptions, type UseHotkeysTarget, type UseHover, type UseHoverOptions, type UseIdleOptions, type UseIdleReturn, type UseImageOptions, type UseImageReturn, type UseInfiniteScroll, type UseInfiniteScrollOptions, type UseIntersectionObserver, type UseIntersectionObserverOptions, type UseIntersectionObserverReturn, type UseIntervalOptions, type UseIntervalReturn, type UseKeyPress, type UseKeyPressCallback, type UseKeyPressEvent, type UseKeyPressEventKey, type UseKeyPressEventOptions, type UseKeyPressKey, type UseKeyboard, type UseKeyboardOptions, type UseKeysPressed, type UseKeysPressedOptions, type UseLastChangedOptions, type UseListReturn, type UseLongPressBind, type UseLongPressOptions, type UseLongPressReturn, type UseLongPressTarget, type UseMapReturn, type UseMeasure, type UseMeasureReturn, type UseMemoryReturn, type UseMouse, type UseMouseReturn, type UseMutationObserver, type UseMutationObserverOptions, type UseMutationObserverReturn, type UseMutationObserverTarget, type UseNetworkReturn, type UseOffsetPaginationOptions, type UseOffsetPaginationReturn, type UseOptimisticReturn, type UseOrientationReturn, type UseOtpCredential, type UseOtpCredentialCallback, type UseOtpCredentialParams, type UseOtpCredentialReturn, type UsePaint, type UsePaintOptions, type UsePaintReturn, type UseParallax, type UseParallaxOptions, type UseParallaxValue, type UsePerformanceObserverOptions, type UsePermissionName, type UsePermissionOptions, type UsePermissionReturn, type UsePostMessageReturn, type UsePreferredColorSchemeReturn, type UsePreferredContrastReturn, type UsePreferredReducedMotionReturn, type UsePreviousOptions, type UseQueryOptions, type UseQueryReturn, type UseQueueReturn, type UseRafCallback, type UseRafOptions, type UseRafParams, type UseRafReturn, type UseRafValueReturn, type UseRenderInfoReturn, type UseResizeObserver, type UseResizeObserverOptions, type UseResizeObserverReturn, type UseScreenOrientationValue, type UseScriptOptions, type UseScriptStatus, type UseScroll, type UseScrollCallbackParams, type UseScrollIntoView, type UseScrollIntoViewOptions, type UseScrollIntoViewReturn, type UseScrollOptions, type UseScrollTo, type UseScrollToOptions, type UseScrollToReturn, type UseShareParams, type UseShareReturn, type UseSticky, type UseStickyAxis, type UseStickyOptions, type UseStickyReturn, type UseStopwatchOptions, type UseStopwatchReturn, type UseStorageInitialValue, type UseStorageOptions, type UseStorageReturn, type UseTextDirection, type UseTextDirectionReturn, type UseTextDirectionValue, type UseTextSelectionReturn, type UseTimeReturn, type UseTimer, type UseTimerOptions, type UseTimerReturn, type UseToggleReturn, type UseVibratePattern, type UseVibrateReturn, type UseWebSocketOptions, type UseWebSocketReturn, type UseWebSocketStatus, type UseWebSocketUrl, type UseWindowSizeReturn, type WizardItem, clearCookies, copy, debounce, dispatchCookieEvent, dispatchStorageEvent, getConnection, getCookie, getCookies, getDate, getElement, getOperatingSystem, getParsedCookies, getRangesSelection, getRetry, getTimeFromSeconds, isHotkeyMatch, isTarget, legacyCopyToClipboard, mapGamepadToXbox360Controller, removeCookie, removeCookieItem, scrollTo, setCookie, setCookieItem, target, targetSymbol, throttle, useActiveElement, useAsync, useBattery, useBluetooth, useBoolean, useBreakpoints, useBrowserLanguage, useClickOutside, useClipboard, useConst, useCookie, useCookies, useCopy, useCounter, useCssVar, useDebounceCallback, useDebounceValue, useDefault, useDeviceMotion, useDeviceOrientation, useDevicePixelRatio, useDidUpdate, useDisclosure, useDisplayMedia, useDocumentEvent, useDocumentTitle, useDocumentVisibility, useElementSize, useEvent, useEventListener, useEyeDropper, useFavicon, useField, useFileDialog, useFocus, useFps, useFullscreen, useGamepad, useGeolocation, useHash, useHotkeys, useHover, useIdle, useImage, useInfiniteScroll, useIntersectionObserver, useInterval, useIsFirstRender, useIsomorphicLayoutEffect, useKeyPress, useKeyPressEvent, useKeyboard, useKeysPressed, useLastChanged, useLatest, useLess, useList, useLocalStorage, useLockCallback, useLogger, useLongPress, useMap, useMeasure, useMediaQuery, useMemory, useMount, useMouse, useMutation, useMutationObserver, useNetwork, useOffsetPagination, useOnline, useOperatingSystem, useOptimistic, useOrientation, useOtpCredential, usePageLeave, usePaint, useParallax, usePerformanceObserver, usePermission, usePointerLock, usePostMessage, usePreferredColorScheme, usePreferredContrast, usePreferredDark, usePreferredLanguages, usePreferredReducedMotion, usePrevious, useQuery, useQueue, useRaf, useRafValue, useRefState, useRenderCount, useRenderInfo, useRerender, useResizeObserver, useScreenOrientation, type useScreenOrientationReturn, useScript, useScroll, useScrollIntoView, useScrollTo, useSessionStorage, useSet, useShare, useStateHistory, useStep, useSticky, useStopwatch, useStorage, useTextDirection, useTextSelection, useThrottleCallback, useThrottleValue, useTime, useTimeout, useTimer, useToggle, useUnmount, useVibrate, useWebSocket, useWindowEvent, useWindowFocus, useWindowScroll, useWindowSize, useWizard };
+export * from './hooks';
+export * from './utils/helpers';