@siberiacancode/reactuse 0.0.102 → 0.0.104

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 import * as react from 'react';
-import { DependencyList, RefObject, Dispatch, SetStateAction, EffectCallback, ComponentProps, useEffect, MouseEventHandler, TouchEventHandler, MouseEvent as MouseEvent$1 } 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
@@ -296,11 +297,9 @@ interface StateRef<Value> {
  */
 declare const useRefState: <Value>(initialValue?: Value) => StateRef<Value>;
 
-/** The use click outside target element type */
-type UseClickOutsideTarget = string | Element | RefObject<Element | null | undefined>;
 interface UseClickOutside {
-    <Target extends UseClickOutsideTarget>(target: Target, callback: (event: Event) => void): void;
-    <Target extends UseClickOutsideTarget>(callback: (event: Event) => void, target?: never): StateRef<Target>;
+    (target: HookTarget$1, callback: (event: Event) => void): void;
+    <Target extends Element>(callback: (event: Event) => void, target?: never): StateRef<Target>;
 }
 /**
  * @name useClickOutside
@@ -308,8 +307,7 @@ interface UseClickOutside {
  * @category Sensors
  *
  * @overload
- * @template Target The target element(s)
- * @param {Target} target The target element(s) to detect outside clicks for
+ * @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}
  *
@@ -457,6 +455,35 @@ declare const useCookies: <Value>() => {
     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 */
@@ -508,8 +535,6 @@ interface UseCounter {
  */
 declare const useCounter: UseCounter;
 
-/** The css variable target element type */
-type UseCssVarTarget = (() => Element) | Element | RefObject<Element | null | undefined> | undefined;
 /** The css variable return type */
 interface UseCssVarReturn {
     /** The value of the CSS variable */
@@ -518,8 +543,10 @@ interface UseCssVarReturn {
     set: (value: string) => void;
 }
 interface UseCssVar {
-    (key: string, initialValue?: string): UseCssVarReturn;
-    <Target extends UseCssVarTarget>(target: Target, key: string, initialValue?: string): UseCssVarReturn;
+    (key: string, initialValue?: string): UseCssVarReturn & {
+        ref: StateRef<Element>;
+    };
+    (target: HookTarget$1, key: string, initialValue?: string): UseCssVarReturn;
 }
 /**
  * @name useCssVar
@@ -529,20 +556,19 @@ interface UseCssVar {
  * @overload
  * @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
+ * @returns {UseCssVarReturn & { ref: StateRef<Element> }} The object containing the value of the CSS variable and ref
  *
  * @example
- * const { ref, value, set } = useCssVar('color', 'red');
+ * const { ref, value, set } = useCssVar('--color', 'red');
  *
  * @overload
- * @template Target The target element
- * @param {Target} target The target element
+ * @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');
+ * const { value, set } = useCssVar(ref, '--color', 'red');
  */
 declare const useCssVar: UseCssVar;
 
@@ -738,15 +764,13 @@ interface UseDisplayMediaOptions {
     /** Whether to enable audio sharing */
     audio?: boolean | MediaTrackConstraints;
     /** Whether to start immediately */
-    enabled?: boolean;
+    immediately?: boolean;
     /** Whether to enable video sharing */
     video?: boolean | MediaTrackConstraints;
 }
-/** The use display media target type */
-type UseDisplayMediaTarget = string | HTMLVideoElement | RefObject<HTMLVideoElement | null | undefined>;
-interface UseDisplayMediaOverload {
-    <Target extends UseDisplayMediaTarget>(target: Target, options?: UseDisplayMediaOptions): UseDisplayMediaReturn;
-    <Target extends UseDisplayMediaTarget = HTMLVideoElement>(options?: UseDisplayMediaOptions, target?: Target): {
+interface UseDisplayMedia {
+    (target: HookTarget$1, options?: UseDisplayMediaOptions): UseDisplayMediaReturn;
+    <Target extends HTMLVideoElement>(options?: UseDisplayMediaOptions, target?: never): {
         ref: StateRef<Target>;
     } & UseDisplayMediaReturn;
 }
@@ -758,10 +782,9 @@ interface UseDisplayMediaOverload {
  * @browserapi mediaDevices.getDisplayMedia https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getDisplayMedia
  *
  * @overload
- * @template Target The target video element
- * @param {Target} target The target video element to display the media stream
+ * @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.enabled=false] Whether to start immediately
+ * @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
  *
@@ -771,25 +794,23 @@ interface UseDisplayMediaOverload {
  * @overload
  * @template Target The target video element
  * @param {boolean | MediaTrackConstraints} [options.audio] Whether to enable audio sharing
- * @param {boolean} [options.enabled=false] Whether to start immediately
+ * @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: UseDisplayMediaOverload;
+declare const useDisplayMedia: UseDisplayMedia;
 
-/** The use event listener target type */
-type UseEventListenerTarget = string | Document | Element | RefObject<Element | null | undefined> | Window;
 /** The use event listener options */
 type UseEventListenerOptions = boolean | AddEventListenerOptions;
 /** The use event listener return type */
-type UseEventListenerReturn<Target extends UseEventListenerTarget> = RefObject<Target>;
+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;
-    <Target extends UseEventListenerTarget, Event extends keyof HTMLElementEventMap = keyof HTMLElementEventMap>(target: Target, event: Event | Event[], listener: (this: Target, event: HTMLElementEventMap[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>;
 }
@@ -823,7 +844,7 @@ interface UseEventListener {
  * @overload
  * @template Event Key of window event map
  * @template Target The target element
- * @param {Target} target The target element to attach the event listener to
+ * @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
@@ -906,15 +927,13 @@ interface UseElementSizeValue {
     /** The element's width */
     width: number;
 }
-/** The use element size target element type */
-type UseElementSizeTarget = string | Element | RefObject<Element | null | undefined>;
 /** The use element size return type */
 interface UseElementSizeReturn {
     value: UseElementSizeValue;
 }
 interface UseElementSize {
-    <Target extends UseElementSizeTarget>(target: Target): UseElementSizeReturn;
-    <Target extends UseElementSizeTarget>(target?: never): {
+    (target: HookTarget$1): UseElementSizeReturn;
+    <Target extends Element>(target?: never): {
         ref: StateRef<Target>;
     } & UseElementSizeReturn;
 }
@@ -924,8 +943,7 @@ interface UseElementSize {
  * @category Elements
  *
  * @overload
- * @template Target The target element type
- * @param {UseElementSizeTarget} target The target element to observe
+ * @param {HookTarget} target The target element to observe
  * @returns {UseElementSizeReturn} An object containing the current width and height of the element
  *
  * @example
@@ -1155,27 +1173,29 @@ interface UseFileDialog {
  */
 declare const useFileDialog: UseFileDialog;
 
-/** The use focus target type */
-type UseFocusTarget = string | Element | RefObject<Element | null | undefined>;
 /** 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;
-    /** Is the target focused */
+    /** Blur the target */
     blur: () => void;
-    /** Is the target focused */
+    /** Focus the target */
     focus: () => void;
 }
 interface UseFocus {
-    <Target extends UseFocusTarget>(options?: UseFocusOptions): UseFocusReturn & {
+    (target: HookTarget$1, options?: UseFocusOptions): UseFocusReturn;
+    <Target extends Element>(options?: UseFocusOptions, target?: never): UseFocusReturn & {
         ref: StateRef<Target>;
     };
-    <Target extends UseFocusTarget>(target: Target, options?: UseFocusOptions): UseFocusReturn;
 }
 /**
  * @name useFocus
@@ -1183,17 +1203,21 @@ interface UseFocus {
  * @category Browser
  *
  * @overload
- * @template Target The target element
- * @param {Target} target The target element to focus
+ * @param {HookTarget} target The target element to focus
  * @param {boolean} [options.initialValue=false] The initial focus state of the target
- * @returns {UseFocusReturn} An object with a `focus` boolean state value
+ * @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
- * @returns {UseFocusReturn} An object with a `focus` boolean state value
+ * @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();
@@ -1214,8 +1238,6 @@ declare const useFocus: UseFocus;
  */
 declare const useFps: () => number;
 
-/** The use fullscreen target element type */
-type UseFullScreenTarget = string | Element | RefObject<Element | null | undefined>;
 /** The use fullscreen options type */
 interface UseFullScreenOptions {
     /** initial value */
@@ -1237,8 +1259,8 @@ interface UseFullScreenReturn {
     toggle: () => void;
 }
 interface UseFullScreen {
-    <Target extends UseFullScreenTarget>(target: Target, options?: UseFullScreenOptions): UseFullScreenReturn;
-    <Target extends UseFullScreenTarget>(options?: UseFullScreenOptions, target?: never): UseFullScreenReturn & {
+    (target: HookTarget$1, options?: UseFullScreenOptions): UseFullScreenReturn;
+    <Target extends Element>(options?: UseFullScreenOptions, target?: never): UseFullScreenReturn & {
         ref: StateRef<Target>;
     };
 }
@@ -1248,8 +1270,7 @@ interface UseFullScreen {
  * @category Browser
  *
  * @overload
- * @template Target The target element for fullscreen
- * @param {Target} target The target element for fullscreen
+ * @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
@@ -1416,8 +1437,8 @@ interface UseHotkeysKey {
 /** The use hotkeys target type */
 type UseHotkeysTarget = Element | React.RefObject<Element | null | undefined>;
 interface UseHotkeys {
-    <Target extends UseHotkeysTarget>(target: Target, hotkeys: UseHotkeysHotkeys, callback: (event: KeyboardEvent) => void, options?: UseHotkeysOptions): void;
-    <Target extends UseHotkeysTarget>(hotkeys: UseHotkeysHotkeys, callback: (event: KeyboardEvent) => void, options?: UseHotkeysOptions, target?: never): StateRef<Target>;
+    (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
@@ -1425,8 +1446,7 @@ interface UseHotkeys {
  * @category Sensors
  *
  * @overload
- * @template Target The target element
- * @param {Target} [target=window] The target element to attach the event listener to
+ * @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
@@ -1453,8 +1473,6 @@ interface UseHotkeys {
  */
 declare const useHotkeys: UseHotkeys;
 
-/** The use hover target type */
-type UseHoverTarget = string | Element | RefObject<Element | null | undefined>;
 /** The use hover options type */
 interface UseHoverOptions {
     /** The on entry callback */
@@ -1463,10 +1481,10 @@ interface UseHoverOptions {
     onLeave?: (event: Event) => void;
 }
 interface UseHover {
-    <Target extends UseHoverTarget>(target: Target, callback?: (event: Event) => void): boolean;
-    <Target extends UseHoverTarget>(target: Target, options?: UseHoverOptions): boolean;
-    <Target extends UseHoverTarget>(callback?: (event: Event) => void, target?: never): [StateRef<Target>, boolean];
-    <Target extends UseHoverTarget>(options?: UseHoverOptions, target?: never): [StateRef<Target>, boolean];
+    (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
@@ -1474,8 +1492,7 @@ interface UseHover {
  * @category Sensors
  *
  * @overload
- * @template Target The target element
- * @param {Target} target The target element to be hovered
+ * @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
  *
@@ -1483,8 +1500,7 @@ interface UseHover {
  * const hovering = useHover(ref, () => console.log('callback'));
  *
  * @overload
- * @template Target The target element
- * @param {Target} target The target element to be hovered
+ * @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
@@ -1633,8 +1649,6 @@ type UseImageReturn = UseQueryReturn<HTMLImageElement>;
  */
 declare const useImage: (src: string, options?: UseImageOptions, useQueryOptions?: Omit<UseQueryOptions<HTMLImageElement, HTMLImageElement>, "initialData" | "placeholderData" | "select">) => UseQueryReturn<HTMLImageElement>;
 
-/** The use infinite scroll target element type */
-type UseInfiniteScrollTarget = string | Element | RefObject<Element | null>;
 /** The use infinite scroll options type */
 interface UseInfiniteScrollOptions {
     /** The direction to trigger the callback */
@@ -1643,11 +1657,11 @@ interface UseInfiniteScrollOptions {
     distance?: number;
 }
 interface UseInfiniteScroll {
-    <Target extends UseInfiniteScrollTarget>(callback: (event: Event) => void, options?: UseInfiniteScrollOptions, target?: never): {
+    (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;
     };
-    <Target extends UseInfiniteScrollTarget>(target: Target, callback: (event: Event) => void, options?: UseInfiniteScrollOptions): boolean;
 }
 /**
  * @name useInfiniteScroll
@@ -1665,8 +1679,7 @@ interface UseInfiniteScroll {
  * const { ref, loading } = useInfiniteScroll(() => console.log('infinite scroll'));
  *
  * @overload
- * @template Target The target element
- * @param {Target} target The target element to detect infinite scroll for
+ * @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
@@ -1677,12 +1690,10 @@ interface UseInfiniteScroll {
  */
 declare const useInfiniteScroll: UseInfiniteScroll;
 
-/** The intersection observer target element type */
-type UseIntersectionObserverTarget = string | Element | RefObject<Element | null | undefined>;
 /** The intersection observer options type */
 interface UseIntersectionObserverOptions extends Omit<IntersectionObserverInit, 'root'> {
     enabled?: boolean;
-    root?: string | IntersectionObserverInit['root'] | RefObject<Element | null | undefined>;
+    root?: HookTarget$1;
     onChange?: (entry: IntersectionObserverEntry) => void;
 }
 /** The intersection observer return type */
@@ -1691,10 +1702,10 @@ interface UseIntersectionObserverReturn {
     inView: boolean;
 }
 interface UseIntersectionObserver {
-    <Target extends UseIntersectionObserverTarget>(options?: UseIntersectionObserverOptions, target?: never): UseIntersectionObserverReturn & {
+    <Target extends Element>(options?: UseIntersectionObserverOptions, target?: never): UseIntersectionObserverReturn & {
         ref: StateRef<Target>;
     };
-    <Target extends UseIntersectionObserverTarget>(target: Target, options?: UseIntersectionObserverOptions): UseIntersectionObserverReturn;
+    (target: HookTarget$1, options?: UseIntersectionObserverOptions): UseIntersectionObserverReturn;
 }
 /**
  * @name useIntersectionObserver
@@ -1702,11 +1713,10 @@ interface UseIntersectionObserver {
  * @category Browser
  *
  * @overload
- * @template Target The target element
- * @param {Target} target The target element to detect intersection
+ * @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 {IntersectionObserverInit['root'] | RefObject<Element | null | undefined>} [options.root] The root element to observe
+ * @param {HookTarget} [options.root] The root element to observe
  * @returns {UseIntersectionObserverReturn} An object containing the state and the supported status
  *
  * @example
@@ -1716,7 +1726,7 @@ interface UseIntersectionObserver {
  * @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 {IntersectionObserverInit['root'] | RefObject<Element | null | undefined>} [options.root] The root element to observe
+ * @param {HookTarget} [options.root] The root element to observe
  * @returns {UseIntersectionObserverReturn & { ref: StateRef<Target> }} A React ref to attach to the target element
  *
  * @example
@@ -1792,56 +1802,96 @@ declare const useIsFirstRender: () => boolean;
  */
 declare const useIsomorphicLayoutEffect: typeof useEffect;
 
-/** The use key press options type */
-interface UseKeyboardParams {
-    /** The target to attach the event listeners to */
-    target?: UseEventListenerTarget;
+/** 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?: (event: KeyboardEvent) => void;
+    onKeyDown?: KeyboardEventHandler;
     /** The callback function to be invoked on key up */
-    onKeyUp?: (event: KeyboardEvent) => void;
+    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 help to listen for keyboard events
+ * @description - Hook that helps to listen for keyboard events
  * @category Sensors
  *
- * @param {UseEventListenerTarget} [target=window] The target to attach the event listeners to
- * @param {(event: KeyboardEvent) => void} [onKeyDown] The callback function to be invoked on key down
- * @param {(event: KeyboardEvent) => void} [onKeyUp] The callback function to be invoked on key up
+ * @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
- * useKeyboard({ onKeyDown: () => console.log('key down'), onKeyUp: () => console.log('key up') })
+ * const ref = useKeyboard({ onKeyDown: (event) => console.log('key down'), onKeyUp: (event) => console.log('key up') });
  */
-declare const useKeyboard: (params?: UseKeyboardParams) => void;
+declare const useKeyboard: UseKeyboard;
 
 /** The key or keys to listen for */
 type UseKeyPressKey = string | string[];
-/** The use key press options type */
-interface UseKeyPressOptions {
-    /** The target to attach the event listeners to */
-    target?: UseEventListenerTarget;
+/** 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 {UseEventListenerTarget} [options.target=window] The target to attach the event listeners to
- * @returns {useKeyPressReturns} Return boolean type (`true` if the specified keys are currently pressed)
+ * @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 isKeyPressed = useKeyPress('a');
+ * const { pressed, ref } = useKeyPress('a');
  */
-declare const useKeyPress: (key: UseKeyPressKey, options?: UseKeyPressOptions) => boolean;
+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 {
-    (key: UseKeyPressEventKey, target: Window, listener: (this: Window, event: WindowEventMap['keydown']) => void, options?: UseEventListenerOptions): void;
-    (key: UseKeyPressEventKey, target: Document, listener: (this: Document, event: DocumentEventMap['keydown']) => void, options?: UseEventListenerOptions): void;
-    <Target extends UseEventListenerTarget>(key: UseKeyPressEventKey, target: Target, listener: (this: Target, event: HTMLElementEventMap['keydown']) => void, options?: UseEventListenerOptions): void;
-    <Target extends Element>(key: UseKeyPressEventKey, listener: (this: Target, event: HTMLElementEventMap['keydown']) => void, options?: UseEventListenerOptions, target?: never): void;
+    (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
@@ -1850,70 +1900,68 @@ interface UseKeyPressEvent {
  *
  * @overload
  * @param {UseKeyPressEventKey} key The key or array of keys to listen for.
- * @param {Window} target The window object 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 {UseEventListenerOptions} [options] The options for the event listener.
- * @returns {void}
- *
- * @example
- * useKeyPressEvent('Enter', window, () => console.log('Enter key pressed'));
- *
- * @overload
- * @param {UseKeyPressEventKey} key The key or array of keys to listen for.
- * @param {Document} target The document object 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 {UseEventListenerOptions} [options] The options for the event listener.
- * @returns {void}
- *
- * @example
- * useKeyPressEvent('Enter', document, () => console.log('Enter key pressed'));
- *
- * @overload
- * @template Target The target element type.
- * @param {UseKeyPressEventKey} key The key or array of keys to listen for.
- * @param {Target} target The target element to attach the event listener to.
+ * @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 {UseEventListenerOptions} [options] The options for the event listener.
+ * @param {UseKeyPressEventOptions} [options] The options for the event listener.
  * @returns {void}
  *
  * @example
- * useKeyPressEvent('Enter', ref, () => console.log('Enter key pressed'));
+ * 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 {UseEventListenerOptions} [options] The options for the event listener.
- * @returns {void}
+ * @param {UseKeyPressEventOptions} [options] The options for the event listener.
+ * @returns {{ ref: StateRef<Target> }} An object containing the ref
  *
  * @example
- * useKeyPressEvent('Enter', (event) => console.log('Enter key pressed'));
+ * const ref = useKeyPressEvent('Enter', (event) => console.log('pressed'));
  */
 declare const useKeyPressEvent: UseKeyPressEvent;
 
-/** The use keys pressed params type */
-interface UseKeysPressedParams {
+/** The use keys pressed options type */
+interface UseKeysPressedOptions {
     /** Enable or disable the event listeners */
     enabled?: boolean;
-    /** The target to attach the event listeners to */
-    target?: UseEventListenerTarget;
+}
+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 - Hook for get keys that were pressed
+ * @description Tracks all currently pressed keyboard keys and their codes
  * @category Sensors
  *
- * @param {UseEventListenerTarget} [params.target=window] The target to attach the event listeners to
- * @param {boolean} [params.enabled=bollean] Enable or disable the event listeners
- * @returns {useKeysPressedReturns} Array of strings with keys that were press
+ * @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 pressedKeys = useKeysPressed();
+ * const { value, ref } = useKeysPressed();
  */
-declare const useKeysPressed: (params?: UseKeysPressedParams) => {
-    key: string;
-    code: string;
-}[];
+declare const useKeysPressed: UseKeysPressed;
 
 /** The use last changed options type  */
 interface UseLastChangedOptions {
@@ -2145,14 +2193,12 @@ interface UseMapReturn<Key, Value> {
  */
 declare const useMap: <Key, Value>(values?: [Key, Value][]) => UseMapReturn<Key, Value>;
 
-/** The use measure target element type */
-type UseMeasureTarget = (() => Element) | Element | RefObject<Element | null | undefined>;
 /** The use measure return type */
 type UseMeasureReturn = Pick<DOMRectReadOnly, 'bottom' | 'height' | 'left' | 'right' | 'top' | 'width' | 'x' | 'y'>;
-interface UseMeasureScreen {
-    <Target extends UseMeasureTarget>(target: Target): UseMeasureReturn;
-    <Target extends UseMeasureTarget>(target?: never): UseMeasureReturn & {
-        ref: RefObject<Target>;
+interface UseMeasure {
+    (target: HookTarget$1): UseMeasureReturn;
+    <Target extends Element>(target?: never): UseMeasureReturn & {
+        ref: StateRef<Target>;
     };
 }
 /**
@@ -2161,8 +2207,7 @@ interface UseMeasureScreen {
  * @category Browser
  *
  * @overload
- * @template Target The element to measure
- * @param {Target} [target] The element to measure
+ * @param {HookTarget} target The element to measure
  * @returns {UseMeasureReturn} The element's size and position
  *
  * @example
@@ -2170,12 +2215,12 @@ interface UseMeasureScreen {
  *
  * @overload
  * @template Target The element to measure
- * @returns {UseMeasureReturn & { ref: RefObject<Target> }} The element's size and position
+ * @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: UseMeasureScreen;
+declare const useMeasure: UseMeasure;
 
 /**
  * @name useMediaQuery
@@ -2234,8 +2279,6 @@ declare const useMemory: () => UseMemoryReturn;
  */
 declare const useMount: (effect: EffectCallback) => void;
 
-/** The use mouse target element type */
-type UseMouseTarget = (() => Element) | string | Element | RefObject<Element | null | undefined>;
 /** The use mouse return type */
 interface UseMouseReturn {
     /** The current element */
@@ -2254,9 +2297,9 @@ interface UseMouseReturn {
     y: number;
 }
 interface UseMouse {
-    <Target extends UseMouseTarget>(target: Target): UseMouseReturn;
-    <Target extends UseMouseTarget>(target?: never): UseMouseReturn & {
-        ref: (node: Target) => void;
+    (target: HookTarget$1): UseMouseReturn;
+    <Target extends Element>(target?: never): UseMouseReturn & {
+        ref: StateRef<Target>;
     };
 }
 /**
@@ -2265,8 +2308,7 @@ interface UseMouse {
  * @category Sensors
  *
  * @overload
- * @template Target The target element
- * @param {Target} target The target element to manage the mouse position for
+ * @param {HookTarget} target The target element to manage the mouse position for
  * @returns {UseMouseReturn} An object with the current mouse position
  *
  * @example
@@ -2274,7 +2316,7 @@ interface UseMouse {
  *
  * @overload
  * @template Target The target element
- * @returns {UseMouseReturn & { ref: (node: Target) => void }} An object with the current mouse position and a ref
+ * @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();
@@ -2318,7 +2360,7 @@ interface RequestOptions<Data> extends UseMutationOptions<Data> {
 declare const useMutation: <Body, Data>(callback: (body: Body) => Promise<Data>, options?: UseMutationOptions<Data>) => UseMutationReturn<Body, Data>;
 
 /** The mutation observer target element type */
-type UseMutationObserverTarget = string | Document | Element | RefObject<Element | null | undefined>;
+type UseMutationObserverTarget = HookTarget$1;
 /** The mutation observer return type */
 interface UseMutationObserverReturn {
     /** The mutation observer instance */
@@ -2332,8 +2374,8 @@ interface UseMutationObserverOptions extends MutationObserverInit {
     enabled?: boolean;
 }
 interface UseMutationObserver {
-    <Target extends UseMutationObserverTarget>(target: Target, callback: MutationCallback, options?: UseMutationObserverOptions): UseMutationObserverReturn;
-    <Target extends UseMutationObserverTarget>(callback: MutationCallback, options?: UseMutationObserverOptions, target?: never): UseMutationObserverReturn & {
+    (target: HookTarget$1, callback: MutationCallback, options?: UseMutationObserverOptions): UseMutationObserverReturn;
+    <Target extends Element>(callback: MutationCallback, options?: UseMutationObserverOptions, target?: never): UseMutationObserverReturn & {
         ref: StateRef<Target>;
     };
 }
@@ -2359,8 +2401,7 @@ interface UseMutationObserver {
  * const { ref, observer, stop } = useMutationObserver(() => console.log('callback'))
  *
  * @overload
- * @template Target The target element
- * @param {Target} target The target element to observe
+ * @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
@@ -2698,13 +2739,11 @@ interface UsePaintReturn {
     draw: (points: Point[], color: string, opacity: number, radius: number) => void;
     undo: () => void;
 }
-/** The use paint return type */
-type UsePaintTarget = (() => HTMLCanvasElement) | HTMLCanvasElement | RefObject<HTMLCanvasElement>;
 interface UsePaint {
-    <Target extends UsePaintTarget>(target: Target, options?: UsePaintOptions): UsePaintReturn;
-    (options?: UsePaintOptions, target?: never): {
-        ref: RefObject<HTMLCanvasElement>;
-    } & UsePaintReturn;
+    (target: HookTarget$1, options?: UsePaintOptions): UsePaintReturn;
+    <Target extends HTMLCanvasElement>(options?: UsePaintOptions, target?: never): UsePaintReturn & {
+        ref: StateRef<Target>;
+    };
 }
 /**
  * @name usePaint
@@ -2712,8 +2751,7 @@ interface UsePaint {
  * @category Browser
  *
  * @overload
- * @template Target The target element
- * @param {Target} target The target element to be painted
+ * @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
  *
@@ -2722,7 +2760,7 @@ interface UsePaint {
  *
  * @overload
  * @param {UsePaintOptions} [options] The options to be used
- * @returns {UsePaintReturn & { ref: RefObject<HTMLCanvasElement> }} An object containing the current pencil options and functions to interact with the paint
+ * @returns {UsePaintReturn & { ref: StateRef<HTMLCanvasElement> }} An object containing the current pencil options and functions to interact with the paint
  *
  * @example
  * const { ref, drawing } = usePaint();
@@ -2753,8 +2791,8 @@ interface UseParallaxReturn {
     value: UseParallaxValue;
 }
 interface UseParallax {
-    <Target extends UseMouseTarget>(target: Target, options?: UseParallaxOptions): UseParallaxReturn;
-    <Target extends UseMouseTarget>(params?: UseParallaxOptions): UseParallaxReturn & {
+    (target: HookTarget$1, options?: UseParallaxOptions): UseParallaxReturn;
+    <Target extends Element>(options?: UseParallaxOptions, target?: never): UseParallaxReturn & {
         ref: StateRef<Target>;
     };
 }
@@ -2764,13 +2802,12 @@ interface UseParallax {
  * @category Sensors
  *
  * @overload
- * @template Target The target element for the parallax effect
- * @param {Target} target The target element for the parallax effect
+ * @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 { roll, tilt, source } = useParallax(ref);
+ * const { value } = useParallax(ref);
  *
  * @overload
  * @template Target The target element for the parallax effect
@@ -2778,7 +2815,7 @@ interface UseParallax {
  * @returns {UseParallaxReturn & { ref: StateRef<Target> }} An object of parallax values
  *
  * @example
- * const { ref, roll, tilt, source } = useParallax();
+ * const { ref, value } = useParallax();
  */
 declare const useParallax: UseParallax;
 
@@ -3100,8 +3137,6 @@ type UseRerenderReturn = () => void;
  */
 declare const useRerender: () => UseRerenderReturn;
 
-/** The resize observer target element type */
-type UseResizeObserverTarget = string | Element | RefObject<Element | null | undefined>;
 /** The resize observer options type */
 interface UseResizeObserverOptions extends ResizeObserverOptions {
     /** The enabled state */
@@ -3115,8 +3150,8 @@ interface UseResizeObserverReturn {
     entries: ResizeObserverEntry[];
 }
 interface UseResizeObserver {
-    <Target extends UseResizeObserverTarget>(target: Target, options?: UseResizeObserverOptions): UseResizeObserverReturn;
-    <Target extends UseResizeObserverTarget>(options?: UseResizeObserverOptions, target?: never): UseResizeObserverReturn & {
+    (target: HookTarget$1, options?: UseResizeObserverOptions): UseResizeObserverReturn;
+    <Target extends Element>(options?: UseResizeObserverOptions, target?: never): UseResizeObserverReturn & {
         ref: StateRef<Target>;
     };
 }
@@ -3132,14 +3167,14 @@ interface UseResizeObserver {
  *  @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: (node: Target) => void }} An object containing the resize observer state
+ *  @returns {UseResizeObserverReturn & { ref: StateRef<Target> }} An object containing the resize observer state
  *
  *  @example
  *  const { ref, entries } = useResizeObserver();
  *
  *  @overload
  *  @template Target The target element
- *  @param {Target} target The target element to observe
+ *  @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
@@ -3210,8 +3245,6 @@ interface UseScriptOptions extends ComponentProps<'script'> {
  */
 declare const useScript: (src: string, options?: UseScriptOptions) => UseScriptStatus;
 
-/** The use scroll target element type */
-type UseScrollTarget = string | Document | Element | RefObject<Element | null | undefined> | Window;
 interface UseScrollOptions {
     /** The on scroll callback */
     onScroll?: (params: UseScrollCallbackParams, event: Event) => void;
@@ -3246,13 +3279,13 @@ interface UseScrollCallbackParams {
     };
 }
 interface UseScroll {
-    <Target extends UseScrollTarget>(target: Target, callback?: (params: UseScrollCallbackParams, event: Event) => void): boolean;
-    <Target extends UseScrollTarget>(target: Target, options?: UseScrollOptions): boolean;
-    <Target extends UseScrollTarget>(callback?: (params: UseScrollCallbackParams, event: Event) => void, target?: never): {
+    (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 UseScrollTarget>(options?: UseScrollOptions, target?: never): {
+    <Target extends Element>(options?: UseScrollOptions, target?: never): {
         ref: StateRef<Target>;
         scrolling: boolean;
     };
@@ -3315,8 +3348,6 @@ interface UseScrollIntoViewOptions extends ScrollIntoViewOptions {
     /** Whether to enable the scroll into view */
     enabled?: boolean;
 }
-/** The scroll into view target type */
-type UseScrollIntoViewTarget = string | Element | RefObject<Element | null | undefined>;
 /** The scroll into view return type */
 interface UseScrollIntoViewReturn {
     /** Function to scroll element into view */
@@ -3326,11 +3357,11 @@ interface UseScrollIntoViewReturn {
         inline?: ScrollLogicalPosition;
     }) => void;
 }
-interface UseScrollIntoViewOverload {
-    <Target extends UseScrollIntoViewTarget>(target: Target, options?: UseScrollIntoViewOptions): UseScrollIntoViewReturn;
-    <Target extends UseScrollIntoViewTarget>(options?: UseScrollIntoViewOptions, target?: never): {
+interface UseScrollIntoView {
+    <Target extends Element>(options?: UseScrollIntoViewOptions, target?: never): UseScrollIntoViewReturn & {
         ref: StateRef<Target>;
-    } & UseScrollIntoViewReturn;
+    };
+    (target: HookTarget$1, options?: UseScrollIntoViewOptions): UseScrollIntoViewReturn;
 }
 /**
  * @name useScrollIntoView
@@ -3338,8 +3369,7 @@ interface UseScrollIntoViewOverload {
  * @category Sensors
  *
  * @overload
- * @template Target The target element
- * @param {Target} target The target element to scroll into view
+ * @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
@@ -3358,10 +3388,8 @@ interface UseScrollIntoViewOverload {
  * @example
  * const { ref, trigger } = useScrollIntoView<HTMLDivElement>();
  */
-declare const useScrollIntoView: UseScrollIntoViewOverload;
+declare const useScrollIntoView: UseScrollIntoView;
 
-/** The use scroll target element type */
-type UseScrollToTarget = string | Document | Element | RefObject<Element | null | undefined> | Window;
 /** The use scroll to options type */
 interface UseScrollToOptions {
     /** The scrolling behavior */
@@ -3383,10 +3411,10 @@ interface UseScrollToReturn {
     }) => void;
 }
 interface UseScrollTo {
-    <Target extends UseScrollToTarget>(target: Target): UseScrollToReturn;
-    <Target extends UseScrollToTarget>(options?: UseScrollToOptions): UseScrollToReturn & {
+    <Target extends Element>(options?: UseScrollToOptions, target?: never): UseScrollToReturn & {
         ref: StateRef<Target>;
     };
+    (target: HookTarget$1, options?: UseScrollToOptions): UseScrollToReturn;
 }
 /**
  * @name useScrollTo
@@ -3394,22 +3422,17 @@ interface UseScrollTo {
  * @category Sensors
  *
  * @overload
- * @template Target The target element(s)
- * @param {Target} target The target element for scrolling to
- * @param {number} options.x The horizontal position to scroll to
- * @param {number} options.y The vertical position to scroll to
- * @param {ScrollBehavior} [options.behavior = 'auto'] The scrolling behavior
- * @returns {boolean} The state of scrolling
+ * @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(s)
- * @param {number} options.x The horizontal position to scroll to
- * @param {number} options.y The vertical position to scroll to
- * @param {ScrollBehavior} [options.behavior = 'auto'] The scrolling behavior
- * @returns {StateRef<Target>} The state of scrolling
+ * @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);
@@ -3652,8 +3675,6 @@ interface UseStopwatch {
  */
 declare const useStopwatch: UseStopwatch;
 
-/** The use text direction target element type */
-type UseTextDirectionTarget = string | Element | RefObject<Element | null | undefined>;
 /** The use text direction value type */
 type UseTextDirectionValue = 'auto' | 'ltr' | 'rtl';
 /** The use text direction return type */
@@ -3666,8 +3687,8 @@ interface UseTextDirectionReturn {
     set: (value: UseTextDirectionValue | null) => void;
 }
 interface UseTextDirection {
-    <Target extends UseTextDirectionTarget>(target: Target, initialValue?: UseTextDirectionValue): UseTextDirectionReturn;
-    <Target extends UseTextDirectionTarget>(initialValue?: UseTextDirectionValue, target?: never): UseTextDirectionReturn & {
+    (target: HookTarget$1, initialValue?: UseTextDirectionValue): UseTextDirectionReturn;
+    <Target extends Element>(initialValue?: UseTextDirectionValue, target?: never): UseTextDirectionReturn & {
         ref: StateRef<Target>;
     };
 }
@@ -3677,18 +3698,17 @@ interface UseTextDirection {
  * @category Browser
  *
  * @overload
- * @template Target The target element type.
- * @param {UseTextDirectionTarget} 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.
+ * @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.
+ * @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();
@@ -4095,13 +4115,22 @@ declare const getDate: (now?: Date) => {
     timestamp: number;
 };
 
-type GetElementTarget = (() => Element) | string | Document | Element | RefObject<Element | null | undefined> | Window;
-declare const getElement: <Target extends GetElementTarget>(target: Target) => Element | (Target & Document) | (Target & Window) | null | undefined;
+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: any) => any;
+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 GetElementTarget, type LongPressReactEvents, type OperatingSystem, type OrientationLockType, Paint, type Point, Pointer, type RemoveCookieParams, type RequestOptions, SCRIPT_STATUS_ATTRIBUTE_NAME, STORAGE_EVENT, type ScrollPosition, type SetCookieParams, type StateRef, type UseAsyncReturn, type UseBatteryStateReturn, type UseBatteryValue, type UseBluetoothOptions, type UseBluetoothReturn, type UseBooleanReturn, type UseBreakpointsReturn, type UseBreakpointsStrategy, type UseClickOutside, type UseClickOutsideTarget, type UseCookieInitialValue, type UseCookieOptions, type UseCookieReturn, type UseCopyToClipboardParams, type UseCopyToClipboardReturn, type UseCounter, type UseCounterOptions, type UseCounterReturn, type UseCssVar, type UseCssVarReturn, type UseCssVarTarget, type UseDeviceMotionParams, type UseDeviceMotionReturn, type UseDeviceOrientationReturn, type UseDeviceOrientationValue, type UseDevicePixelRatioReturn, type UseDisclosureOptions, type UseDisclosureReturn, type UseDisplayMediaOptions, type UseDisplayMediaOverload, type UseDisplayMediaReturn, type UseDisplayMediaTarget, type UseDocumentTitleOptions, type UseDocumentTitleReturn, type UseElementSize, type UseElementSizeReturn, type UseElementSizeTarget, type UseElementSizeValue, type UseEventListener, type UseEventListenerOptions, type UseEventListenerReturn, type UseEventListenerTarget, type UseEyeDropperReturn, type UseFaviconReturn, type UseFieldParams, type UseFieldRegisterParams, type UseFieldReturn, type UseFileDialog, type UseFileDialogOptions, type UseFileDialogReturn, type UseFocus, type UseFocusOptions, type UseFocusReturn, type UseFocusTarget, type UseFullScreen, type UseFullScreenOptions, type UseFullScreenReturn, type UseFullScreenTarget, type UseGamepadStateReturn, type UseGeolocationParams, type UseGeolocationReturn, type UseHotkeys, type UseHotkeysHotkeys, type UseHotkeysKey, type UseHotkeysOptions, type UseHotkeysTarget, type UseHover, type UseHoverOptions, type UseHoverTarget, type UseIdleOptions, type UseIdleReturn, type UseImageOptions, type UseImageReturn, type UseInfiniteScroll, type UseInfiniteScrollOptions, type UseInfiniteScrollTarget, type UseIntersectionObserver, type UseIntersectionObserverOptions, type UseIntersectionObserverReturn, type UseIntersectionObserverTarget, type UseIntervalOptions, type UseIntervalReturn, type UseKeyPressEvent, type UseKeyPressEventKey, type UseKeyPressKey, type UseKeyPressOptions, type UseKeyboardParams, type UseKeysPressedParams, type UseLastChangedOptions, type UseListReturn, type UseLongPressBind, type UseLongPressOptions, type UseLongPressReturn, type UseLongPressTarget, type UseMapReturn, type UseMeasureReturn, type UseMeasureScreen, type UseMeasureTarget, type UseMemoryReturn, type UseMouse, type UseMouseReturn, type UseMouseTarget, 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 UsePaintTarget, 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 UseResizeObserverTarget, type UseScreenOrientationValue, type UseScriptOptions, type UseScriptStatus, type UseScroll, type UseScrollCallbackParams, type UseScrollIntoViewOptions, type UseScrollIntoViewOverload, type UseScrollIntoViewReturn, type UseScrollIntoViewTarget, type UseScrollOptions, type UseScrollTarget, type UseScrollTo, type UseScrollToOptions, type UseScrollToReturn, type UseScrollToTarget, type UseShareParams, type UseShareReturn, type UseStopwatchOptions, type UseStopwatchReturn, type UseStorageInitialValue, type UseStorageOptions, type UseStorageReturn, type UseTextDirection, type UseTextDirectionReturn, type UseTextDirectionTarget, 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, getCookies, getDate, getElement, getOperatingSystem, getParsedCookies, getRangesSelection, getRetry, getTimeFromSeconds, isHotkeyMatch, isTarget, legacyCopyToClipboard, mapGamepadToXbox360Controller, removeCookie, scrollTo, setCookie, throttle, useActiveElement, useAsync, useBattery, useBluetooth, useBoolean, useBreakpoints, useBrowserLanguage, useClickOutside, useClipboard, useConst, useCookie, useCookies, 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, 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, useStopwatch, useStorage, useTextDirection, useTextSelection, useThrottleCallback, useThrottleValue, useTime, useTimeout, useTimer, useToggle, useUnmount, useVibrate, useWebSocket, useWindowEvent, useWindowFocus, useWindowScroll, useWindowSize, useWizard };
+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 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 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, getCookies, getDate, getElement, getOperatingSystem, getParsedCookies, getRangesSelection, getRetry, getTimeFromSeconds, isHotkeyMatch, isTarget, legacyCopyToClipboard, mapGamepadToXbox360Controller, removeCookie, scrollTo, setCookie, 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, 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, useStopwatch, useStorage, useTextDirection, useTextSelection, useThrottleCallback, useThrottleValue, useTime, useTimeout, useTimer, useToggle, useUnmount, useVibrate, useWebSocket, useWindowEvent, useWindowFocus, useWindowScroll, useWindowSize, useWizard };