@ts-hooks-kit/core 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1688 @@
+import { Dispatch, RefObject, SetStateAction, useEffect } from "react";
+
+//#region src/useAsync/useAsync.d.ts
+/**
+* Represents the state of an async operation.
+* @template T - The type of the resolved value.
+*/
+/**
+ * Represents the state of an async operation.
+ * @template T - The type of the resolved value.
+ */
+type UseAsyncState<T> = {
+  /** Whether the async operation is in progress. */
+  loading: boolean;
+  /** The resolved value if the operation succeeded. */
+  value: T | undefined;
+  /** The error if the operation failed. */
+  error: Error | undefined;
+  /** Function to retry the async operation. */
+  retry: () => void;
+};
+/**
+ * Custom hook that manages the state of an async function.
+ * @template T - The type of the resolved value.
+ * @param {() => Promise<T>} asyncFn - The async function to execute.
+ * @param {unknown[]} [deps] - Dependencies that trigger re-execution when changed.
+ * @returns {UseAsyncState<T>} The state of the async operation.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-async)
+ * @example
+ * ```tsx
+ * const { value, error, loading, retry } = useAsync(async () => {
+ *   const response = await fetch('/api/data');
+ *   return response.json();
+ * }, []);
+ * ```
+ */
+declare function useAsync<T>(asyncFn: () => Promise<T>, deps?: unknown[]): UseAsyncState<T>;
+
+//#endregion
+//#region src/useBoolean/useBoolean.d.ts
+/** The useBoolean return type. */
+type UseBooleanReturn = {
+  /** The current boolean state value. */
+  value: boolean;
+  /** Function to set the boolean state directly. */
+  setValue: Dispatch<SetStateAction<boolean>>;
+  /** Function to set the boolean state to `true`. */
+  setTrue: () => void;
+  /** Function to set the boolean state to `false`. */
+  setFalse: () => void;
+  /** Function to toggle the boolean state. */
+  toggle: () => void;
+};
+/**
+ * Custom hook that handles boolean state with useful utility functions.
+ * @param {boolean} [defaultValue] - The initial value for the boolean state (default is `false`).
+ * @returns {UseBooleanReturn} An object containing the boolean state value and utility functions to manipulate the state.
+ * @throws Will throw an error if `defaultValue` is an invalid boolean value.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-boolean)
+ * @example
+ * ```tsx
+ * const { value, setTrue, setFalse, toggle } = useBoolean(true);
+ * ```
+ */
+declare function useBoolean(defaultValue?: boolean): UseBooleanReturn;
+
+//#endregion
+//#region src/useClickAnyWhere/useClickAnyWhere.d.ts
+/**
+ * Custom hook that handles click events anywhere on the document.
+ * @param {Function} handler - The function to be called when a click event is detected anywhere on the document.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-click-any-where)
+ * @example
+ * ```tsx
+ * const handleClick = (event) => {
+ *   console.log('Document clicked!', event);
+ * };
+ *
+ * // Attach click event handler to document
+ * useClickAnywhere(handleClick);
+ * ```
+ */
+declare function useClickAnyWhere(handler: (event: MouseEvent) => void): void;
+
+//#endregion
+//#region src/useCopyToClipboard/useCopyToClipboard.d.ts
+/**
+ * The copied text as `string` or `null` if nothing has been copied yet.
+ */
+type CopiedValue = string | null;
+/**
+ * Function to copy text to the clipboard.
+ * @param text - The text to copy to the clipboard.
+ * @returns {Promise<boolean>} A promise that resolves to `true` if the text was copied successfully, or `false` otherwise.
+ */
+type CopyFn = (text: string) => Promise<boolean>;
+/**
+ * Custom hook that copies text to the clipboard using the [`Clipboard API`](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API).
+ * @returns {[CopiedValue, CopyFn]} An tuple containing the copied text and a function to copy text to the clipboard.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-copy-to-clipboard)
+ * @example
+ * ```tsx
+ * const [copiedText, copyToClipboard] = useCopyToClipboard();
+ * const textToCopy = 'Hello, world!';
+ *
+ * // Attempt to copy text to the clipboard
+ * copyToClipboard(textToCopy)
+ *   .then(success => {
+ *     if (success) {
+ *       console.log(`Text "${textToCopy}" copied to clipboard successfully.`);
+ *     } else {
+ *       console.error('Failed to copy text to clipboard.');
+ *     }
+ *   });
+ * ```
+ */
+declare function useCopyToClipboard(): [CopiedValue, CopyFn];
+
+//#endregion
+//#region src/useCountdown/useCountdown.d.ts
+/** The countdown's options. */
+type CountdownOptions = {
+  /** The countdown's starting number, initial value of the returned number. */
+  countStart: number;
+  /**
+   * The countdown's interval, in milliseconds.
+   * @default 1000
+   */
+  intervalMs?: number;
+  /**
+   * True if the countdown is increment.
+   * @default false
+   */
+  isIncrement?: boolean;
+  /**
+   * The countdown's stopping number. Pass `-Infinity` to decrease forever.
+   * @default 0
+   */
+  countStop?: number;
+};
+/** The countdown's controllers. */
+type CountdownControllers = {
+  /** Start the countdown. */
+  startCountdown: () => void;
+  /** Stop the countdown. */
+  stopCountdown: () => void;
+  /** Reset the countdown. */
+  resetCountdown: () => void;
+};
+/**
+ * Custom hook that manages countdown.
+ * @param {CountdownOptions} countdownOptions - The countdown's options.
+ * @returns {[number, CountdownControllers]} An array containing the countdown's count and its controllers.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-countdown)
+ * @example
+ * ```tsx
+ * const [counter, { start, stop, reset }] = useCountdown({
+ *   countStart: 10,
+ *   intervalMs: 1000,
+ *   isIncrement: false,
+ * });
+ * ```
+ */
+declare function useCountdown({
+  countStart,
+  countStop,
+  intervalMs,
+  isIncrement
+}: CountdownOptions): [number, CountdownControllers];
+
+//#endregion
+//#region src/useCounter/useCounter.d.ts
+/** The hook return type. */
+type UseCounterReturn = {
+  /** The current count value. */
+  count: number;
+  /** Function to increment the counter by 1. */
+  increment: () => void;
+  /** Function to decrement the counter by 1. */
+  decrement: () => void;
+  /** Function to reset the counter to its initial value. */
+  reset: () => void;
+  /** Function to set a specific value to the counter. */
+  setCount: Dispatch<SetStateAction<number>>;
+};
+/**
+ * Custom hook that manages a counter with increment, decrement, reset, and setCount functionalities.
+ * @param {number} [initialValue] - The initial value for the counter.
+ * @returns {UseCounterReturn} An object containing the current count and functions to interact with the counter.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-counter)
+ * @example
+ * ```tsx
+ * const { count, increment, decrement, reset, setCount } = useCounter(5);
+ * ```
+ */
+declare function useCounter(initialValue?: number): UseCounterReturn;
+
+//#endregion
+//#region src/useDarkMode/useDarkMode.d.ts
+/** The hook options. */
+type DarkModeOptions = {
+  /**
+   * The initial value of the dark mode.
+   * @default false
+   */
+  defaultValue?: boolean;
+  /**
+   * The key to use in the local storage.
+   * @default 'usehooks-ts-dark-mode'
+   */
+  localStorageKey?: string;
+  /**
+   * If `true` (default), the hook will initialize reading `localStorage`.
+   * In SSR, you should set it to `false`, returning the `defaultValue` or `false` initially.
+   * @default true
+   */
+  initializeWithValue?: boolean;
+};
+/** The hook return type. */
+type DarkModeReturn = {
+  /** The current state of the dark mode. */
+  isDarkMode: boolean;
+  /** Function to toggle the dark mode. */
+  toggle: () => void;
+  /** Function to enable the dark mode. */
+  enable: () => void;
+  /** Function to disable the dark mode. */
+  disable: () => void;
+  /** Function to set a specific value to the dark mode. */
+  set: (value: boolean) => void;
+};
+/**
+ * Custom hook that returns the current state of the dark mode.
+ * @param {?DarkModeOptions} [options] - The initial value of the dark mode, default `false`.
+ * @returns {DarkModeReturn} An object containing the dark mode's state and its controllers.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-dark-mode)
+ * @example
+ * ```tsx
+ * const { isDarkMode, toggle, enable, disable, set } = useDarkMode({ defaultValue: true });
+ * ```
+ */
+declare function useDarkMode(options?: DarkModeOptions): DarkModeReturn;
+
+//#endregion
+//#region src/utils/debounce.d.ts
+/** Options for controlling debounce behavior. */
+interface DebounceOptions {
+  /** Invoke on the leading edge of the timeout. */
+  leading?: boolean;
+  /** Invoke on the trailing edge of the timeout. */
+  trailing?: boolean;
+  /** Maximum time to delay before invoking. */
+  maxWait?: number;
+}
+
+//#endregion
+//#region src/useDebounceCallback/useDebounceCallback.d.ts
+/** A debounced function with control methods. */
+/** Functions to manage a debounced callback. */
+type ControlFunctions = {
+  /** Cancels pending function invocations. */
+  cancel: () => void;
+  /** Immediately invokes pending function invocations. */
+  flush: () => void;
+  /**
+   * Checks if there are any pending function invocations.
+   * @returns `true` if there are pending invocations, otherwise `false`.
+   */
+  isPending: () => boolean;
+};
+/**
+ * Represents the state and control functions of a debounced callback.
+ * Subsequent calls to the debounced function return the result of the last invocation.
+ * Note: If there are no previous invocations, the result will be undefined.
+ * Ensure proper handling in your code.
+ */
+type DebouncedState<T extends (...args: any) => ReturnType<T>> = ((...args: Parameters<T>) => ReturnType<T> | undefined) & ControlFunctions;
+/**
+ * Custom hook that creates a debounced version of a callback function.
+ * @template T - Type of the original callback function.
+ * @param {T} func - The callback function to be debounced.
+ * @param {number} delay - The delay in milliseconds before the callback is invoked (default is `500` milliseconds).
+ * @param {DebounceOptions} [options] - Options to control the behavior of the debounced function.
+ * @returns {DebouncedState<T>} A debounced version of the original callback along with control functions.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-debounce-callback)
+ * @example
+ * ```tsx
+ * const debouncedCallback = useDebounceCallback(
+ *   (searchTerm) => {
+ *     // Perform search after user stops typing for 500 milliseconds
+ *     searchApi(searchTerm);
+ *   },
+ *   500
+ * );
+ *
+ * // Later in the component
+ * debouncedCallback('react hooks'); // Will invoke the callback after 500 milliseconds of inactivity.
+ * ```
+ */
+declare function useDebounceCallback<T extends (...args: any) => ReturnType<T>>(func: T, delay?: number, options?: DebounceOptions): DebouncedState<T>;
+
+//#endregion
+//#region src/useDebounceValue/useDebounceValue.d.ts
+/**
+ * Hook options.
+ * @template T - The type of the value.
+ */
+type UseDebounceValueOptions<T> = {
+  /**
+   * Determines whether the function should be invoked on the leading edge of the timeout.
+   * @default false
+   */
+  leading?: boolean;
+  /**
+   * Determines whether the function should be invoked on the trailing edge of the timeout.
+   * @default false
+   */
+  trailing?: boolean;
+  /**
+   * The maximum time the specified function is allowed to be delayed before it is invoked.
+   */
+  maxWait?: number;
+  /** A function to determine if the value has changed. Defaults to a function that checks if the value is strictly equal to the previous value. */
+  equalityFn?: (left: T, right: T) => boolean;
+};
+/**
+ * Custom hook that returns a debounced version of the provided value, along with a function to update it.
+ * @template T - The type of the value.
+ * @param {T | (() => T)} initialValue - The value to be debounced.
+ * @param {number} delay - The delay in milliseconds before the value is updated (default is 500ms).
+ * @param {object} [options] - Optional configurations for the debouncing behavior.
+ * @returns {[T, DebouncedState<(value: T) => void>]} An array containing the debounced value and the function to update it.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-debounce-value)
+ * @example
+ * ```tsx
+ * const [debouncedValue, updateDebouncedValue] = useDebounceValue(inputValue, 500, { leading: true });
+ * ```
+ */
+declare function useDebounceValue<T>(initialValue: T | (() => T), delay: number, options?: UseDebounceValueOptions<T>): [T, DebouncedState<(value: T) => void>];
+
+//#endregion
+//#region src/useDisclosure/useDisclosure.d.ts
+/**
+ * Options for the useDisclosure hook.
+ */
+type UseDisclosureOptions = {
+  /** Callback fired when disclosure opens. */
+  onOpen?: () => void;
+  /** Callback fired when disclosure closes. */
+  onClose?: () => void;
+};
+/**
+ * Represents the actions returned by useDisclosure hook.
+ */
+type UseDisclosureActions = {
+  /** Open the disclosure. */
+  open: () => void;
+  /** Close the disclosure. */
+  close: () => void;
+  /** Toggle the disclosure state. */
+  toggle: () => void;
+};
+/**
+ * Represents the return type of the `useDisclosure` hook.
+ */
+type UseDisclosureReturn = [boolean, UseDisclosureActions];
+/**
+ * Custom hook for managing boolean disclosure state (modals, popovers, drawers, etc.).
+ * @param {boolean} [initialState=false] - The initial open state.
+ * @param {UseDisclosureOptions} [options] - Optional callbacks for open/close events.
+ * @returns {UseDisclosureReturn} A tuple containing the open state and control actions.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-disclosure)
+ * @example
+ * ```tsx
+ * const [opened, { open, close, toggle }] = useDisclosure(false, {
+ *   onOpen: () => console.log('Opened'),
+ *   onClose: () => console.log('Closed'),
+ * });
+ *
+ * return (
+ *   <>
+ *     <button onClick={open}>Open Modal</button>
+ *     <Modal opened={opened} onClose={close}>
+ *       <button onClick={close}>Close</button>
+ *     </Modal>
+ *   </>
+ * );
+ * ```
+ */
+declare function useDisclosure(initialState?: boolean, options?: UseDisclosureOptions): UseDisclosureReturn;
+
+//#endregion
+//#region src/useDocumentTitle/useDocumentTitle.d.ts
+/** Hook options. */
+type UseDocumentTitleOptions = {
+  /** Whether to keep the title after unmounting the component (default is `true`). */
+  preserveTitleOnUnmount?: boolean;
+};
+/**
+ * Custom hook that sets the document title.
+ * @param {string} title - The title to set.
+ * @param {?UseDocumentTitleOptions} [options] - The options.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-document-title)
+ * @example
+ * ```tsx
+ * useDocumentTitle('My new title');
+ * ```
+ */
+declare function useDocumentTitle(title: string, options?: UseDocumentTitleOptions): void;
+
+//#endregion
+//#region src/useEventCallback/useEventCallback.d.ts
+/**
+ * Custom hook that creates a memoized event callback.
+ * @template Args - An array of argument types for the event callback.
+ * @template R - The return type of the event callback.
+ * @param {(...args: Args) => R} fn - The callback function.
+ * @returns {(...args: Args) => R} A memoized event callback function.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-event-callback)
+ * @example
+ * ```tsx
+ * const handleClick = useEventCallback((event) => {
+ *   // Handle the event here
+ * });
+ * ```
+ */
+declare function useEventCallback<Args extends unknown[], R>(fn: (...args: Args) => R): (...args: Args) => R;
+declare function useEventCallback<Args extends unknown[], R>(fn: ((...args: Args) => R) | undefined): ((...args: Args) => R) | undefined;
+
+//#endregion
+//#region src/useEventListener/useEventListener.d.ts
+declare function useEventListener<K extends keyof MediaQueryListEventMap>(eventName: K, handler: (event: MediaQueryListEventMap[K]) => void, element: RefObject<MediaQueryList | null>, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener<K extends keyof WindowEventMap>(eventName: K, handler: (event: WindowEventMap[K]) => void, element?: undefined, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener<K extends keyof HTMLElementEventMap & keyof SVGElementEventMap, T extends Element = (K extends keyof HTMLElementEventMap ? HTMLDivElement : SVGElement)>(eventName: K, handler: ((event: HTMLElementEventMap[K]) => void) | ((event: SVGElementEventMap[K]) => void), element: RefObject<T | null>, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener<K extends keyof DocumentEventMap>(eventName: K, handler: (event: DocumentEventMap[K]) => void, element: RefObject<Document | null>, options?: boolean | AddEventListenerOptions): void;
+
+//#endregion
+//#region src/useGeolocation/useGeolocation.d.ts
+/**
+ * Represents the state of geolocation.
+ */
+type UseGeolocationState = {
+  /** The latitude coordinate. */
+  latitude: number | undefined;
+  /** The longitude coordinate. */
+  longitude: number | undefined;
+  /** The accuracy of the location in meters. */
+  accuracy: number | undefined;
+  /** The altitude in meters. */
+  altitude: number | null | undefined;
+  /** The accuracy of the altitude in meters. */
+  altitudeAccuracy: number | null | undefined;
+  /** The heading in degrees (0-360). */
+  heading: number | null | undefined;
+  /** The speed in meters per second. */
+  speed: number | null | undefined;
+  /** The timestamp of the position. */
+  timestamp: number | undefined;
+  /** Whether the geolocation is loading. */
+  loading: boolean;
+  /** The error object if geolocation failed. */
+  error: GeolocationPositionError | Error | undefined;
+};
+/**
+ * Options for the useGeolocation hook.
+ * Extends the standard PositionOptions with an enabled flag.
+ */
+type UseGeolocationOptions = {
+  /** Whether to enable high accuracy mode. */
+  enableHighAccuracy?: boolean;
+  /** The maximum time in milliseconds allowed to get the position. */
+  timeout?: number;
+  /** The maximum age in milliseconds of a cached position. */
+  maximumAge?: number;
+  /** Whether to enable geolocation. Set to false to prevent fetching. */
+  enabled?: boolean;
+};
+/**
+ * Custom hook that provides access to the browser's geolocation API.
+ * @param {UseGeolocationOptions} [options] - Options for geolocation and hook behavior.
+ * @returns {UseGeolocationState} The current geolocation state.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-geolocation)
+ * @example
+ * ```tsx
+ * const { latitude, longitude, loading, error } = useGeolocation({
+ *   enableHighAccuracy: true,
+ *   timeout: 5000,
+ * });
+ *
+ * if (loading) return <div>Loading location...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * return <div>Location: {latitude}, {longitude}</div>;
+ * ```
+ */
+declare function useGeolocation(options?: UseGeolocationOptions): UseGeolocationState;
+
+//#endregion
+//#region src/useHover/useHover.d.ts
+/**
+ * Custom hook that tracks whether a DOM element is being hovered over.
+ * @template T - The type of the DOM element. Defaults to `HTMLElement`.
+ * @param {RefObject<T>} elementRef - The ref object for the DOM element to track.
+ * @returns {boolean} A boolean value indicating whether the element is being hovered over.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-hover)
+ * @example
+ * ```tsx
+ * const buttonRef = useRef<HTMLButtonElement>(null);
+ * const isHovered = useHover(buttonRef);
+ * // Access the isHovered variable to determine if the button is being hovered over.
+ * ```
+ */
+declare function useHover<T extends HTMLElement = HTMLElement>(elementRef: RefObject<T | null>): boolean;
+
+//#endregion
+//#region src/useIdle/useIdle.d.ts
+/**
+ * Options for the useIdle hook.
+ */
+type UseIdleOptions = {
+  /** Events that should reset the idle timer. */
+  events?: (keyof WindowEventMap)[];
+  /** Whether to start in idle state. */
+  initialIdle?: boolean;
+};
+/**
+ * Represents the state returned by useIdle hook.
+ */
+type IdleState = {
+  /** Whether the user is currently idle. */
+  idle: boolean;
+  /** The timestamp of the last user activity. */
+  lastActive: number;
+};
+/**
+ * Custom hook that tracks whether the user is idle (no activity for a specified time).
+ * @param {number} timeout - The time in milliseconds of inactivity before considering the user idle.
+ * @param {UseIdleOptions} [options] - Options for customizing the hook behavior.
+ * @returns {IdleState} The current idle state and last activity timestamp.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-idle)
+ * @example
+ * ```tsx
+ * const { idle, lastActive } = useIdle(5000);
+ *
+ * return (
+ *   <div>
+ *     <p>{idle ? 'User is idle' : 'User is active'}</p>
+ *     <p>Last active: {new Date(lastActive).toLocaleString()}</p>
+ *   </div>
+ * );
+ * ```
+ */
+declare function useIdle(timeout: number, options?: UseIdleOptions): IdleState;
+
+//#endregion
+//#region src/useIntersectionObserver/useIntersectionObserver.d.ts
+/** The hook internal state. */
+type UseIntersectionObserverState = {
+  /** A boolean indicating if the element is intersecting. */
+  isIntersecting: boolean;
+  /** The intersection observer entry. */
+  entry?: IntersectionObserverEntry;
+};
+/** Represents the options for configuring the Intersection Observer. */
+type UseIntersectionObserverOptions = {
+  /**
+   * The element that is used as the viewport for checking visibility of the target.
+   * @default null
+   */
+  root?: Element | Document | null;
+  /**
+   * A margin around the root.
+   * @default '0%'
+   */
+  rootMargin?: string;
+  /**
+   * A threshold indicating the percentage of the target's visibility needed to trigger the callback.
+   * @default 0
+   */
+  threshold?: number | number[];
+  /**
+   * If true, freezes the intersection state once the element becomes visible.
+   * @default false
+   */
+  freezeOnceVisible?: boolean;
+  /**
+   * A callback function to be invoked when the intersection state changes.
+   * @param {boolean} isIntersecting - A boolean indicating if the element is intersecting.
+   * @param {IntersectionObserverEntry} entry - The intersection observer Entry.
+   * @default undefined
+   */
+  onChange?: (isIntersecting: boolean, entry: IntersectionObserverEntry) => void;
+  /**
+   * The initial state of the intersection.
+   * @default false
+   */
+  initialIsIntersecting?: boolean;
+};
+/**
+ * The return type of the useIntersectionObserver hook.
+ *
+ * Supports both tuple and object destructing.
+ * @param {(node: Element | null) => void} ref - The ref callback function.
+ * @param {boolean} isIntersecting - A boolean indicating if the element is intersecting.
+ * @param {IntersectionObserverEntry | undefined} entry - The intersection observer Entry.
+ */
+type IntersectionReturn = [(node?: Element | null) => void, boolean, IntersectionObserverEntry | undefined] & {
+  ref: (node?: Element | null) => void;
+  isIntersecting: boolean;
+  entry?: IntersectionObserverEntry;
+};
+/**
+ * Custom hook that tracks the intersection of a DOM element with its containing element or the viewport using the [`Intersection Observer API`](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API).
+ * @param {UseIntersectionObserverOptions} options - The options for the Intersection Observer.
+ * @returns {IntersectionReturn} The ref callback, a boolean indicating if the element is intersecting, and the intersection observer entry.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-intersection-observer)
+ * @example
+ * ```tsx
+ * // Example 1
+ * const [ref, isIntersecting, entry] = useIntersectionObserver({ threshold: 0.5 });
+ * ```
+ *
+ * ```tsx
+ * // Example 2
+ * const { ref, isIntersecting, entry } = useIntersectionObserver({ threshold: 0.5 });
+ * ```
+ */
+declare function useIntersectionObserver({
+  threshold,
+  root,
+  rootMargin,
+  freezeOnceVisible,
+  initialIsIntersecting,
+  onChange
+}?: UseIntersectionObserverOptions): IntersectionReturn;
+
+//#endregion
+//#region src/useInterval/useInterval.d.ts
+/**
+ * Custom hook that creates an interval that invokes a callback function at a specified delay using the [`setInterval API`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setInterval).
+ * @param {() => void} callback - The function to be invoked at each interval.
+ * @param {number | null} delay - The time, in milliseconds, between each invocation of the callback. Use `null` to clear the interval.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-interval)
+ * @example
+ * ```tsx
+ * const handleInterval = () => {
+ *   // Code to be executed at each interval
+ * };
+ * useInterval(handleInterval, 1000);
+ * ```
+ */
+declare function useInterval(callback: () => void, delay: number | null): void;
+
+//#endregion
+//#region src/useIsClient/useIsClient.d.ts
+/**
+ * Custom hook that determines if the code is running on the client side (in the browser).
+ * @returns {boolean} A boolean value indicating whether the code is running on the client side.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-is-client)
+ * @example
+ * ```tsx
+ * const isClient = useIsClient();
+ * // Use isClient to conditionally render or execute code specific to the client side.
+ * ```
+ */
+declare function useIsClient(): boolean;
+
+//#endregion
+//#region src/useIsMounted/useIsMounted.d.ts
+/**
+ * Custom hook that determines if the component is currently mounted.
+ * @returns {() => boolean} A function that returns a boolean value indicating whether the component is mounted.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-is-mounted)
+ * @example
+ * ```tsx
+ * const isComponentMounted = useIsMounted();
+ * // Use isComponentMounted() to check if the component is currently mounted before performing certain actions.
+ * ```
+ */
+declare function useIsMounted(): () => boolean;
+
+//#endregion
+//#region src/useIsomorphicLayoutEffect/useIsomorphicLayoutEffect.d.ts
+/**
+ * Custom hook that uses either `useLayoutEffect` or `useEffect` based on the environment (client-side or server-side).
+ * @param {Function} effect - The effect function to be executed.
+ * @param {Array<any>} [dependencies] - An array of dependencies for the effect (optional).
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-isomorphic-layout-effect)
+ * @example
+ * ```tsx
+ * useIsomorphicLayoutEffect(() => {
+ *   // Code to be executed during the layout phase on the client side
+ * }, [dependency1, dependency2]);
+ * ```
+ */
+declare const useIsomorphicLayoutEffect: typeof useEffect;
+
+//#endregion
+//#region src/useList/useList.d.ts
+/**
+ * Represents the actions available to interact with the list state.
+ * @template T - The type of elements in the list.
+ */
+type UseListActions<T> = {
+  /** Set a new list. */
+  set: (list: T[]) => void;
+  /** Add value(s) to the end of the list. */
+  push: (...values: T[]) => void;
+  /** Update value at a specific index. */
+  updateAt: (index: number, value: T) => void;
+  /** Insert value at a specific index. */
+  insertAt: (index: number, value: T) => void;
+  /** Remove value at a specific index. */
+  removeAt: (index: number) => void;
+  /** Clear all values from the list. */
+  clear: () => void;
+  /** Reset the list to its initial state. */
+  reset: () => void;
+};
+/**
+ * Represents the return type of the `useList` hook.
+ * @template T - The type of elements in the list.
+ */
+type UseListReturn<T> = [T[], UseListActions<T>];
+/**
+ * Custom hook that manages a list state with setter actions.
+ * @template T - The type of elements in the list.
+ * @param {T[]} [initialValue] - The initial array of values for the list (optional).
+ * @returns {UseListReturn<T>} A tuple containing the list state and actions to interact with the list.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-list)
+ * @example
+ * ```tsx
+ * const [list, listActions] = useList<number>([1, 2, 3]);
+ * // Access the `list` array and use `listActions` to push, updateAt, removeAt, or reset values.
+ * ```
+ */
+declare function useList<T>(initialValue?: T[]): UseListReturn<T>;
+
+//#endregion
+//#region src/useLocalStorage/useLocalStorage.d.ts
+declare global {
+  interface WindowEventMap {
+    'local-storage': CustomEvent;
+  }
+}
+/**
+ * Options for customizing the behavior of serialization and deserialization.
+ * @template T - The type of the state to be stored in local storage.
+ */
+type UseLocalStorageOptions<T> = {
+  /** A function to serialize the value before storing it. */
+  serializer?: (value: T) => string;
+  /** A function to deserialize the stored value. */
+  deserializer?: (value: string) => T;
+  /**
+   * If `true` (default), the hook will initialize reading the local storage. In SSR, you should set it to `false`, returning the initial value initially.
+   * @default true
+   */
+  initializeWithValue?: boolean;
+};
+/**
+ * Custom hook that uses the [`localStorage API`](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage) to persist state across page reloads.
+ * @template T - The type of the state to be stored in local storage.
+ * @param {string} key - The key under which the value will be stored in local storage.
+ * @param {T | (() => T)} initialValue - The initial value of the state or a function that returns the initial value.
+ * @param {UseLocalStorageOptions<T>} [options] - Options for customizing the behavior of serialization and deserialization (optional).
+ * @returns {[T, Dispatch<SetStateAction<T>>, () => void]} A tuple containing the stored value, a function to set the value and a function to remove the key from storage.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-local-storage)
+ * @example
+ * ```tsx
+ * const [count, setCount, removeCount] = useLocalStorage('count', 0);
+ * // Access the `count` value, the `setCount` function to update it and `removeCount` function to remove the key from storage.
+ * ```
+ */
+declare function useLocalStorage<T>(key: string, initialValue: T | (() => T), options?: UseLocalStorageOptions<T>): [T, Dispatch<SetStateAction<T>>, () => void];
+
+//#endregion
+//#region src/useMap/useMap.d.ts
+/**
+ * Represents the type for either a Map or an array of key-value pairs.
+ * @template K - The type of keys in the map.
+ * @template V - The type of values in the map.
+ */
+type MapOrEntries<K, V> = Map<K, V> | [K, V][];
+/**
+ * Represents the actions available to interact with the map state.
+ * @template K - The type of keys in the map.
+ * @template V - The type of values in the map.
+ */
+type UseMapActions<K, V> = {
+  /** Set a key-value pair in the map. */
+  set: (key: K, value: V) => void;
+  /** Set all key-value pairs in the map. */
+  setAll: (entries: MapOrEntries<K, V>) => void;
+  /** Remove a key-value pair from the map. */
+  remove: (key: K) => void;
+  /** Reset the map to an empty state. */
+  reset: Map<K, V>['clear'];
+};
+/**
+ * Represents the return type of the `useMap` hook.
+ * We hide some setters from the returned map to disable autocompletion.
+ * @template K - The type of keys in the map.
+ * @template V - The type of values in the map.
+ */
+type UseMapReturn<K, V> = [Omit<Map<K, V>, 'set' | 'clear' | 'delete'>, UseMapActions<K, V>];
+/**
+ * Custom hook that manages a key-value [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) state with setter actions.
+ * @template K - The type of keys in the map.
+ * @template V - The type of values in the map.
+ * @param {MapOrEntries<K, V>} [initialState] - The initial state of the map as a Map or an array of key-value pairs (optional).
+ * @returns {UseMapReturn<K, V>} A tuple containing the map state and actions to interact with the map.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-map)
+ * @example
+ * ```tsx
+ * const [map, mapActions] = useMap();
+ * // Access the `map` state and use `mapActions` to set, remove, or reset entries.
+ * ```
+ */
+declare function useMap<K, V>(initialState?: MapOrEntries<K, V>): UseMapReturn<K, V>;
+
+//#endregion
+//#region src/useMediaQuery/useMediaQuery.d.ts
+/** Hook options. */
+type UseMediaQueryOptions = {
+  /**
+   * The default value to return if the hook is being run on the server.
+   * @default false
+   */
+  defaultValue?: boolean;
+  /**
+   * If `true` (default), the hook will initialize reading the media query. In SSR, you should set it to `false`, returning `options.defaultValue` or `false` initially.
+   * @default true
+   */
+  initializeWithValue?: boolean;
+};
+/**
+ * Custom hook that tracks the state of a media query using the [`Match Media API`](https://developer.mozilla.org/en-US/docs/Web/API/Window/matchMedia).
+ * @param {string} query - The media query to track.
+ * @param {?UseMediaQueryOptions} [options] - The options for customizing the behavior of the hook (optional).
+ * @returns {boolean} The current state of the media query (true if the query matches, false otherwise).
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-media-query)
+ * @example
+ * ```tsx
+ * const isSmallScreen = useMediaQuery('(max-width: 600px)');
+ * // Use `isSmallScreen` to conditionally apply styles or logic based on the screen size.
+ * ```
+ */
+declare function useMediaQuery(query: string, {
+  defaultValue,
+  initializeWithValue
+}?: UseMediaQueryOptions): boolean;
+
+//#endregion
+//#region src/useMemoizedFn/useMemoizedFn.d.ts
+/**
+ * Custom hook that returns a memoized version of a function that never changes reference.
+ * The returned function will always call the latest version of the callback, but its
+ * identity (reference) will remain stable across renders.
+ *
+ * This is useful when you need to pass a callback to a dependency array or child component
+ * without causing unnecessary re-renders.
+ *
+ * @template T - The type of the function being memoized.
+ * @param {T} fn - The function to memoize.
+ * @returns {T} A memoized function with stable reference.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-memoized-fn)
+ * @example
+ * ```tsx
+ * const stableCallback = useMemoizedFn((value) => {
+ *   console.log(value);
+ * });
+ *
+ * // stableCallback can be safely used in useEffect deps without causing infinite loops
+ * useEffect(() => {
+ *   stableCallback(someValue);
+ * }, [stableCallback]);
+ * ```
+ */
+declare function useMemoizedFn<T extends (...args: any[]) => any>(fn: T): T;
+
+//#endregion
+//#region src/useNetwork/useNetwork.d.ts
+/**
+ * Represents the network state returned by useNetwork hook.
+ */
+type NetworkState = {
+  /** Whether the browser is online. */
+  online: boolean;
+  /** The estimated effective type of the connection. */
+  effectiveType: string | undefined;
+  /** The estimated downlink speed in Mbps. */
+  downlink: number | undefined;
+  /** The maximum downlink speed in Mbps. */
+  downlinkMax: number | undefined;
+  /** The type of connection (e.g., 'wifi', 'cellular'). */
+  type: string | undefined;
+  /** The effective round-trip time estimate in milliseconds. */
+  rtt: number | undefined;
+  /** Whether the user has requested a reduced data usage mode. */
+  saveData: boolean | undefined;
+};
+/**
+ * Custom hook that tracks the browser's network connection status.
+ * @returns {NetworkState} The current network state including online status and connection info.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-network)
+ * @example
+ * ```tsx
+ * const { online, effectiveType, downlink } = useNetwork();
+ *
+ * return (
+ *   <div>
+ *     <p>Status: {online ? 'Online' : 'Offline'}</p>
+ *     <p>Connection: {effectiveType}</p>
+ *     <p>Speed: {downlink} Mbps</p>
+ *   </div>
+ * );
+ * ```
+ */
+declare function useNetwork(): NetworkState;
+
+//#endregion
+//#region src/useOnClickOutside/useOnClickOutside.d.ts
+/** Supported event types. */
+type EventType = 'mousedown' | 'mouseup' | 'touchstart' | 'touchend' | 'focusin' | 'focusout';
+/**
+ * Custom hook that handles clicks outside a specified element.
+ * @template T - The type of the element's reference.
+ * @param {RefObject<T | null> | RefObject<T | null>[]} ref - The React ref object(s) representing the element(s) to watch for outside clicks.
+ * @param {(event: MouseEvent | TouchEvent | FocusEvent) => void} handler - The callback function to be executed when a click outside the element occurs.
+ * @param {EventType} [eventType] - The mouse event type to listen for (optional, default is 'mousedown').
+ * @param {?AddEventListenerOptions} [eventListenerOptions] - The options object to be passed to the `addEventListener` method (optional).
+ * @returns {void}
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-on-click-outside)
+ * @example
+ * ```tsx
+ * const containerRef = useRef(null);
+ * useOnClickOutside([containerRef], () => {
+ *   // Handle clicks outside the container.
+ * });
+ * ```
+ */
+declare function useOnClickOutside<T extends HTMLElement = HTMLElement>(ref: RefObject<T | null> | RefObject<T | null>[], handler: (event: MouseEvent | TouchEvent | FocusEvent) => void, eventType?: EventType, eventListenerOptions?: AddEventListenerOptions): void;
+
+//#endregion
+//#region src/usePageLeave/usePageLeave.d.ts
+/**
+ * Custom hook that invokes a callback when the user's mouse leaves the page.
+ * @param {() => void} handler - The callback function to invoke when the mouse leaves the page.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-page-leave)
+ * @example
+ * ```tsx
+ * usePageLeave(() => {
+ *   console.log('User is leaving the page');
+ *   // Show "Don't leave!" modal or save draft
+ * });
+ * ```
+ */
+declare function usePageLeave(handler: () => void): void;
+
+//#endregion
+//#region src/usePagination/usePagination.d.ts
+/**
+ * Options for the usePagination hook.
+ */
+type UsePaginationOptions = {
+  /** Total number of pages. */
+  total: number;
+  /** Number of sibling pages to show on each side of current page. @default 1 */
+  siblings?: number;
+  /** Number of boundary pages to show at start and end. @default 1 */
+  boundaries?: number;
+  /** Initial active page. @default 1 */
+  initialPage?: number;
+  /** Controlled active page (overrides internal state). */
+  page?: number;
+  /** Callback when page changes (for controlled mode). */
+  onChange?: (page: number) => void;
+};
+/**
+ * Represents the state and actions returned by usePagination hook.
+ */
+type UsePaginationReturn = {
+  /** The currently active page number. */
+  activePage: number;
+  /** The pagination range (pages and separators). */
+  range: (number | string)[];
+  /** Set the active page. */
+  setPage: (page: number) => void;
+  /** Navigate to the next page. */
+  next: () => void;
+  /** Navigate to the previous page. */
+  prev: () => void;
+  /** Whether the current page is the first page. */
+  first: boolean;
+  /** Whether the current page is the last page. */
+  last: boolean;
+};
+declare const DOTS = "dots";
+/**
+ * Custom hook for managing pagination logic.
+ * Returns page navigation functions and a range array suitable for pagination UI.
+ * @param {UsePaginationOptions} options - Pagination configuration options.
+ * @returns {UsePaginationReturn} The pagination state and navigation functions.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-pagination)
+ * @example
+ * ```tsx
+ * const { activePage, setPage, next, prev, range } = usePagination({
+ *   total: 20,
+ *   siblings: 1,
+ *   boundaries: 1,
+ * });
+ *
+ * // range = [1, 'dots', 4, 5, 6, 'dots', 20]
+ * ```
+ */
+declare function usePagination(options: UsePaginationOptions): UsePaginationReturn;
+
+//#endregion
+//#region src/usePermission/usePermission.d.ts
+/**
+ * Represents the state returned by usePermission hook.
+ */
+type PermissionState = {
+  /** The current state of the permission. */
+  state: PermissionStateValue;
+  /** Whether the permission is supported by the browser. */
+  supported: boolean;
+};
+/**
+ * Valid permission state values.
+ */
+type PermissionStateValue = 'granted' | 'denied' | 'prompt' | 'unsupported';
+/**
+ * Valid permission names for the Permissions API.
+ */
+type PermissionName = 'geolocation' | 'notifications' | 'push' | 'midi' | 'camera' | 'microphone' | 'speaker' | 'device-info' | 'background-fetch' | 'background-sync' | 'bluetooth' | 'persistent-storage' | 'ambient-light-sensor' | 'accelerometer' | 'gyroscope' | 'magnetometer' | 'clipboard' | 'display-capture' | 'nfc';
+/**
+ * Custom hook that tracks the state of a browser permission.
+ * @param {PermissionName} permissionName - The name of the permission to track.
+ * @returns {PermissionState} The current state of the permission.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-permission)
+ * @example
+ * ```tsx
+ * const { state, supported } = usePermission('camera');
+ *
+ * if (!supported) return <div>Permissions API not supported</div>;
+ * if (state === 'denied') return <div>Camera access denied</div>;
+ * return <Camera />;
+ * ```
+ */
+declare function usePermission(permissionName: PermissionName): PermissionState;
+
+//#endregion
+//#region src/usePrevious/usePrevious.d.ts
+/**
+ * Returns the previous value of a variable from the last render.
+ * On the first render, returns `undefined` or the provided initial value.
+ *
+ * @template T - The type of the value being tracked
+ * @param value - The current value to track
+ * @returns The value from the previous render
+ *
+ * @example
+ * ```tsx
+ * function Counter() {
+ *   const [count, setCount] = useState(0)
+ *   const prevCount = usePrevious(count)
+ *
+ *   return (
+ *     <div>
+ *       <p>Now: {count}, before: {prevCount}</p>
+ *       <button onClick={() => setCount(c => c + 1)}>Increment</button>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function usePrevious<T>(value: T): T | undefined;
+declare function usePrevious<T, I>(value: T, initialValue: I): T | I;
+
+//#endregion
+//#region src/useQueue/useQueue.d.ts
+/**
+ * Represents the actions available to interact with the queue state.
+ * @template T - The type of elements in the queue.
+ */
+type UseQueueActions<T> = {
+  /** Add a value to the end of the queue. */
+  add: (value: T) => void;
+  /** Remove and return the value from the front of the queue (FIFO). */
+  remove: () => T | undefined;
+  /** Clear all values from the queue. */
+  clear: () => void;
+  /** The first (front) value in the queue. */
+  first: T | undefined;
+  /** The last (back) value in the queue. */
+  last: T | undefined;
+  /** The number of elements in the queue. */
+  size: number;
+};
+/**
+ * Represents the return type of the `useQueue` hook.
+ * @template T - The type of elements in the queue.
+ */
+type UseQueueReturn<T> = [T[], UseQueueActions<T>];
+/**
+ * Custom hook that manages a FIFO (First In, First Out) queue state with setter actions.
+ * @template T - The type of elements in the queue.
+ * @param {T[]} [initialValue] - The initial array of values for the queue (optional).
+ * @returns {UseQueueReturn<T>} A tuple containing the queue state and actions to interact with the queue.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-queue)
+ * @example
+ * ```tsx
+ * const [queue, queueActions] = useQueue<number>([1, 2, 3]);
+ * // Access the `queue` array and use `queueActions` to add, remove, or clear values.
+ * ```
+ */
+declare function useQueue<T>(initialValue?: T[]): UseQueueReturn<T>;
+
+//#endregion
+//#region src/useReadLocalStorage/useReadLocalStorage.d.ts
+/**
+ * Represents the type for the options available when reading from local storage.
+ * @template T - The type of the stored value.
+ */
+type Options<T, InitializeWithValue extends boolean | undefined> = {
+  /** Custom deserializer function to convert the stored string value to the desired type (optional). */
+  deserializer?: (value: string) => T;
+  /** If `true` (default), the hook will initialize reading the local storage. In SSR, you should set it to `false`, returning `undefined` initially. */
+  initializeWithValue: InitializeWithValue;
+};
+declare function useReadLocalStorage<T>(key: string, options: Options<T, false>): T | null | undefined;
+declare function useReadLocalStorage<T>(key: string, options?: Partial<Options<T, true>>): T | null;
+
+//#endregion
+//#region src/useResizeObserver/useResizeObserver.d.ts
+/** The size of the observed element. */
+type Size = {
+  /** The width of the observed element. */
+  width: number | undefined;
+  /** The height of the observed element. */
+  height: number | undefined;
+};
+/** The options for the ResizeObserver. */
+type UseResizeObserverOptions<T extends HTMLElement = HTMLElement> = {
+  /** The ref of the element to observe. */
+  ref: RefObject<T | null>;
+  /**
+   * When using `onResize`, the hook doesn't re-render on element size changes; it delegates handling to the provided callback.
+   * @default undefined
+   */
+  onResize?: (size: Size) => void;
+  /**
+   * The box model to use for the ResizeObserver.
+   * @default 'content-box'
+   */
+  box?: 'border-box' | 'content-box' | 'device-pixel-content-box';
+};
+/**
+ * Custom hook that observes the size of an element using the [`ResizeObserver API`](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver).
+ * @template T - The type of the element to observe.
+ * @param {UseResizeObserverOptions<T>} options - The options for the ResizeObserver.
+ * @returns {Size} - The size of the observed element.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-resize-observer)
+ * @example
+ * ```tsx
+ * const myRef = useRef(null);
+ * const { width = 0, height = 0 } = useResizeObserver({
+ *   ref: myRef,
+ *   box: 'content-box',
+ * });
+ *
+ * <div ref={myRef}>Hello, world!</div>
+ * ```
+ */
+declare function useResizeObserver<T extends HTMLElement = HTMLElement>(options: UseResizeObserverOptions<T>): Size;
+
+//#endregion
+//#region src/useScreen/useScreen.d.ts
+/**
+ * The hooks options.
+ * @template InitializeWithValue - If `true` (default), the hook will initialize reading the screen dimensions. In SSR, you should set it to `false`, returning `undefined` initially.
+ */
+type UseScreenOptions<InitializeWithValue extends boolean | undefined> = {
+  /**
+   * If `true` (default), the hook will initialize reading the screen dimensions. In SSR, you should set it to `false`, returning `undefined` initially.
+   * @default true
+   */
+  initializeWithValue: InitializeWithValue;
+  /**
+   * The delay in milliseconds before the state is updated (disabled by default for retro-compatibility).
+   * @default undefined
+   */
+  debounceDelay?: number;
+};
+declare function useScreen(options: UseScreenOptions<false>): Screen | undefined;
+declare function useScreen(options?: Partial<UseScreenOptions<true>>): Screen;
+
+//#endregion
+//#region src/useScript/useScript.d.ts
+/** Script loading status. */
+type UseScriptStatus = 'idle' | 'loading' | 'ready' | 'error';
+/** Hook options. */
+type UseScriptOptions = {
+  /** If `true`, prevents the script from being loaded (optional). */
+  shouldPreventLoad?: boolean;
+  /** If `true`, removes the script from the DOM when the component unmounts (optional). */
+  removeOnUnmount?: boolean;
+  /** Script's `id` (optional). */
+  id?: string;
+};
+/**
+ * Custom hook that dynamically loads scripts and tracking their loading status.
+ * @param {string | null} src - The source URL of the script to load. Set to `null` or omit to prevent loading (optional).
+ * @param {UseScriptOptions} [options] - Additional options for controlling script loading (optional).
+ * @returns {UseScriptStatus} The status of the script loading, which can be one of 'idle', 'loading', 'ready', or 'error'.
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-script)
+ * @example
+ * const scriptStatus = useScript('https://example.com/script.js', { removeOnUnmount: true });
+ * // Access the status of the script loading (e.g., 'loading', 'ready', 'error').
+ */
+declare function useScript(src: string | null, options?: UseScriptOptions): UseScriptStatus;
+
+//#endregion
+//#region src/useScrollLock/useScrollLock.d.ts
+/** Hook options. */
+type UseScrollLockOptions = {
+  /**
+   * Whether to lock the scroll initially.
+   * @default true
+   */
+  autoLock?: boolean;
+  /**
+   * The target element to lock the scroll (default is the body element).
+   * @default document.body
+   */
+  lockTarget?: HTMLElement | string;
+  /**
+   * Whether to prevent width reflow when locking the scroll.
+   * @default true
+   */
+  widthReflow?: boolean;
+};
+/** Hook return type. */
+type UseScrollLockReturn = {
+  /** Whether the scroll is locked. */
+  isLocked: boolean;
+  /** Lock the scroll. */
+  lock: () => void;
+  /** Unlock the scroll. */
+  unlock: () => void;
+};
+type OriginalStyle = {
+  overflow: CSSStyleDeclaration['overflow'];
+  paddingRight: CSSStyleDeclaration['paddingRight'];
+};
+/**
+ * A custom hook that locks and unlocks scroll.
+ * @param {UseScrollLockOptions} [options] - Options to configure the hook, by default it will lock the scroll automatically.
+ * @returns {UseScrollLockReturn} - An object containing the lock and unlock functions.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-scroll-lock)
+ * @example
+ * ```tsx
+ * // Lock the scroll when the modal is mounted, and unlock it when it's unmounted
+ * useScrollLock()
+ * ```
+ * @example
+ * ```tsx
+ * // Manually lock and unlock the scroll
+ * const { lock, unlock } = useScrollLock({ autoLock: false })
+ *
+ * return (
+ *  <div>
+ *   <button onClick={lock}>Lock</button>
+ *   <button onClick={unlock}>Unlock</button>
+ *  </div>
+ * )
+ * ```
+ */
+declare function useScrollLock(options?: UseScrollLockOptions): UseScrollLockReturn;
+
+//#endregion
+//#region src/useSessionStorage/useSessionStorage.d.ts
+declare global {
+  interface WindowEventMap {
+    'session-storage': CustomEvent;
+  }
+}
+/**
+ * Represents the options for customizing the behavior of serialization and deserialization.
+ * @template T - The type of the state to be stored in session storage.
+ */
+type UseSessionStorageOptions<T> = {
+  /** A function to serialize the value before storing it. */
+  serializer?: (value: T) => string;
+  /** A function to deserialize the stored value. */
+  deserializer?: (value: string) => T;
+  /**
+   * If `true` (default), the hook will initialize reading the session storage. In SSR, you should set it to `false`, returning the initial value initially.
+   * @default true
+   */
+  initializeWithValue?: boolean;
+};
+/**
+ * Custom hook that uses the [`sessionStorage API`](https://developer.mozilla.org/en-US/docs/Web/API/Window/sessionStorage) to persist state across page reloads.
+ * @template T - The type of the state to be stored in session storage.
+ * @param {string} key - The key under which the value will be stored in session storage.
+ * @param {T | (() => T)} initialValue - The initial value of the state or a function that returns the initial value.
+ * @param {?UseSessionStorageOptions<T>} [options] - Options for customizing the behavior of serialization and deserialization (optional).
+ * @returns {[T, Dispatch<SetStateAction<T>>, () => void]} A tuple containing the stored value, a function to set the value and a function to remove the key from storage.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-session-storage)
+ * @example
+ * ```tsx
+ * const [count, setCount, removeCount] = useSessionStorage('count', 0);
+ * // Access the `count` value, the `setCount` function to update it and `removeCount` function to remove the key from storage.
+ * ```
+ */
+declare function useSessionStorage<T>(key: string, initialValue: T | (() => T), options?: UseSessionStorageOptions<T>): [T, Dispatch<SetStateAction<T>>, () => void];
+
+//#endregion
+//#region src/useSet/useSet.d.ts
+/**
+ * Represents the actions available to interact with the set state.
+ * @template T - The type of elements in the set.
+ */
+type UseSetActions<T> = {
+  /** Add a value to the set. */
+  add: (value: T) => void;
+  /** Remove a value from the set. */
+  remove: (value: T) => void;
+  /** Toggle a value in the set (add if not present, remove if present). */
+  toggle: (value: T) => void;
+  /** Check if a value exists in the set. */
+  has: (value: T) => boolean;
+  /** Clear all values from the set. */
+  clear: () => void;
+  /** Reset the set to its initial state. */
+  reset: () => void;
+};
+/**
+ * Represents the return type of the `useSet` hook.
+ * We hide some setters from the returned set to disable autocompletion.
+ * @template T - The type of elements in the set.
+ */
+type UseSetReturn<T> = [Omit<Set<T>, 'add' | 'clear' | 'delete'>, UseSetActions<T>];
+/**
+ * Custom hook that manages a [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) state with setter actions.
+ * @template T - The type of elements in the set.
+ * @param {Set<T> | T[]} [initialValue] - The initial value of the set as a Set or an array of values (optional).
+ * @returns {UseSetReturn<T>} A tuple containing the set state and actions to interact with the set.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-set)
+ * @example
+ * ```tsx
+ * const [set, setActions] = useSet<string>(['hello']);
+ * // Access the `set` state and use `setActions` to add, remove, toggle, or reset values.
+ * ```
+ */
+declare function useSet<T>(initialValue?: Set<T> | T[]): UseSetReturn<T>;
+
+//#endregion
+//#region src/useStateList/useStateList.d.ts
+/**
+ * Represents the state and actions returned by useStateList hook.
+ * @template T - The type of the state values.
+ */
+type UseStateListReturn<T> = {
+  /** The current state value. */
+  state: T;
+  /** The current index in the state list. */
+  currentIndex: number;
+  /** Whether the current state is the first in the list. */
+  isFirst: boolean;
+  /** Whether the current state is the last in the list. */
+  isLast: boolean;
+  /** Navigate to the previous state. */
+  prev: () => void;
+  /** Navigate to the next state. */
+  next: () => void;
+  /** Set the state by index. */
+  setStateAt: (index: number) => void;
+  /** Set the state by value. */
+  setState: (state: T) => void;
+};
+/**
+ * Custom hook for navigating through a list of states.
+ * Useful for step-by-step flows, carousels, or multi-step forms.
+ * @template T - The type of the state values.
+ * @param {T[]} stateSet - The array of possible states.
+ * @returns {UseStateListReturn<T>} The current state and navigation functions.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-state-list)
+ * @example
+ * ```tsx
+ * const states = ['step1', 'step2', 'step3'];
+ * const { state, next, prev, isFirst, isLast } = useStateList(states);
+ *
+ * return (
+ *   <div>
+ *     <p>Current: {state}</p>
+ *     <button onClick={prev} disabled={isFirst}>Back</button>
+ *     <button onClick={next} disabled={isLast}>Next</button>
+ *   </div>
+ * );
+ * ```
+ */
+declare function useStateList<T>(stateSet: T[]): UseStateListReturn<T>;
+
+//#endregion
+//#region src/useStep/useStep.d.ts
+/** Represents the second element of the output of the `useStep` hook. */
+type UseStepActions = {
+  /** Go to the next step in the process. */
+  goToNextStep: () => void;
+  /** Go to the previous step in the process. */
+  goToPrevStep: () => void;
+  /** Reset the step to the initial step. */
+  reset: () => void;
+  /** Check if the next step is available. */
+  canGoToNextStep: boolean;
+  /** Check if the previous step is available. */
+  canGoToPrevStep: boolean;
+  /** Set the current step to a specific value. */
+  setStep: Dispatch<SetStateAction<number>>;
+};
+type SetStepCallbackType = (step: number | ((step: number) => number)) => void;
+/**
+ * Custom hook that manages and navigates between steps in a multi-step process.
+ * @param {number} maxStep - The maximum step in the process.
+ * @returns {[number, UseStepActions]} An tuple containing the current step and helper functions for navigating steps.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-step)
+ * @example
+ * ```tsx
+ * const [currentStep, { goToNextStep, goToPrevStep, reset, canGoToNextStep, canGoToPrevStep, setStep }] = useStep(3);
+ * // Access and use the current step and provided helper functions.
+ * ```
+ */
+declare function useStep(maxStep: number): [number, UseStepActions];
+
+//#endregion
+//#region src/useTernaryDarkMode/useTernaryDarkMode.d.ts
+/** Ternary dark mode options. */
+type TernaryDarkMode = 'system' | 'dark' | 'light';
+/** Options for the `useTernaryDarkMode` hook. */
+type TernaryDarkModeOptions = {
+  /**
+   * The default value for the dark mode.
+   * @default 'system'
+   */
+  defaultValue?: TernaryDarkMode;
+  /**
+   * The key for storing dark mode preference in local storage.
+   * @default 'usehooks-ts-ternary-dark-mode'
+   */
+  localStorageKey?: string;
+  /**
+   * If `true` (default), the hook will initialize reading `localStorage`. In SSR, you should set it to `false`, returning default values initially.
+   * @default true
+   */
+  initializeWithValue?: boolean;
+};
+/** Represents the return type of the `useTernaryDarkMode` hook. */
+type TernaryDarkModeReturn = {
+  /** The current state of the dark mode. */
+  isDarkMode: boolean;
+  /** The current state of the dark mode. */
+  ternaryDarkMode: TernaryDarkMode;
+  /** A function to set the dark mode state. */
+  setTernaryDarkMode: Dispatch<SetStateAction<TernaryDarkMode>>;
+  /** A function to toggle the dark mode state. */
+  toggleTernaryDarkMode: () => void;
+};
+/**
+ * Custom hook that manages ternary (system, dark, light) dark mode with local storage support.
+ * @param {?TernaryDarkModeOptions | string} [options] - Options or the local storage key for the hook.
+ * @returns {TernaryDarkModeReturn} An object containing the dark mode state and helper functions.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-ternary-dark-mode)
+ * @example
+ * ```tsx
+ * const { isDarkMode, ternaryDarkMode, setTernaryDarkMode, toggleTernaryDarkMode } = useTernaryDarkMode({ defaultValue: 'dark' });
+ * // Access and use the dark mode state and provided helper functions.
+ * ```
+ */
+declare function useTernaryDarkMode({
+  defaultValue,
+  localStorageKey,
+  initializeWithValue
+}?: TernaryDarkModeOptions): TernaryDarkModeReturn;
+
+//#endregion
+//#region src/useThrottle/useThrottle.d.ts
+/**
+ * Custom hook that throttles a function, ensuring it is only called at most once per wait period.
+ * @template T - The type of the function being throttled.
+ * @param {T} fn - The function to throttle.
+ * @param {number} wait - The number of milliseconds to throttle invocations to.
+ * @returns {T} The throttled function.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-throttle-fn)
+ * @example
+ * ```tsx
+ * const throttledSave = useThrottleFn(saveToDatabase, 1000);
+ * // Calling throttledSave() multiple times rapidly will only execute saveToDatabase once per second
+ * ```
+ */
+declare function useThrottleFn<T extends (...args: any[]) => any>(fn: T, wait: number): T;
+/**
+ * Custom hook that throttles a value, ensuring updates occur at most once per wait period.
+ * @template T - The type of the value being throttled.
+ * @param {T} value - The value to throttle.
+ * @param {number} wait - The number of milliseconds to throttle updates to.
+ * @returns {T} The throttled value.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-throttle)
+ * @example
+ * ```tsx
+ * const throttledSearchTerm = useThrottle(searchTerm, 300);
+ * // throttledSearchTerm will only update 300ms after the last change to searchTerm
+ * ```
+ */
+declare function useThrottle<T>(value: T, wait: number): T;
+
+//#endregion
+//#region src/useTimeout/useTimeout.d.ts
+/**
+ * Custom hook that handles timeouts in React components using the [`setTimeout API`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout).
+ * @param {() => void} callback - The function to be executed when the timeout elapses.
+ * @param {number | null} delay - The duration (in milliseconds) for the timeout. Set to `null` to clear the timeout.
+ * @returns {void} This hook does not return anything.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-timeout)
+ * @example
+ * ```tsx
+ * // Usage of useTimeout hook
+ * useTimeout(() => {
+ *   // Code to be executed after the specified delay
+ * }, 1000); // Set a timeout of 1000 milliseconds (1 second)
+ * ```
+ */
+declare function useTimeout(callback: () => void, delay: number | null): void;
+
+//#endregion
+//#region src/useToggle/useToggle.d.ts
+/**
+ * Custom hook that manages a boolean toggle state in React components.
+ * @param {boolean} [defaultValue] - The initial value for the toggle state.
+ * @returns {[boolean, () => void, Dispatch<SetStateAction<boolean>>]} A tuple containing the current state,
+ * a function to toggle the state, and a function to set the state explicitly.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-toggle)
+ * @example
+ * ```tsx
+ * const [isToggled, toggle, setToggle] = useToggle(); // Initial value is false
+ * // OR
+ * const [isToggled, toggle, setToggle] = useToggle(true); // Initial value is true
+ * // Use isToggled in your component, toggle to switch the state, setToggle to set the state explicitly.
+ * ```
+ */
+declare function useToggle(defaultValue?: boolean): [boolean, () => void, Dispatch<SetStateAction<boolean>>];
+
+//#endregion
+//#region src/useUnmount/useUnmount.d.ts
+/**
+ * Custom hook that runs a cleanup function when the component is unmounted.
+ * @param {() => void} func - The cleanup function to be executed on unmount.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-unmount)
+ * @example
+ * ```tsx
+ * useUnmount(() => {
+ *   // Cleanup logic here
+ * });
+ * ```
+ */
+declare function useUnmount(func: () => void): void;
+
+//#endregion
+//#region src/useUpdate/useUpdate.d.ts
+/**
+ * Custom hook that returns a function to force a component re-render.
+ * @returns {() => void} A function that, when called, will force the component to re-render.
+ * @public
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-update)
+ * @example
+ * ```tsx
+ * const update = useUpdate();
+ *
+ * return (
+ *   <div>
+ *     <p>Current time: {Date.now()}</p>
+ *     <button onClick={update}>Update</button>
+ *   </div>
+ * );
+ * ```
+ */
+declare function useUpdate(): () => void;
+
+//#endregion
+//#region src/useUpdateEffect/useUpdateEffect.d.ts
+/**
+ * A hook that runs an effect only when dependencies change, skipping the initial mount.
+ * This is useful for responding to prop or state changes without running on first render.
+ *
+ * @param {() => void | (() => void)} effect - The effect function to run.
+ * @param {unknown[]} deps - The dependency array.
+ *
+ * @example
+ * ```tsx
+ * function Component({ value }) {
+ *   useUpdateEffect(() => {
+ *     console.log('Value changed:', value);
+ *   }, [value]);
+ *
+ *   return <div>{value}</div>;
+ * }
+ * ```
+ */
+declare function useUpdateEffect(effect: () => void | (() => void), deps: unknown[]): void;
+
+//#endregion
+//#region src/useWindowSize/useWindowSize.d.ts
+/**
+ * Represent the dimension of the window.
+ * @template T - The type of the dimension (number or undefined).
+ */
+type WindowSize<T extends number | undefined = number | undefined> = {
+  /** The width of the window. */
+  width: T;
+  /** The height of the window. */
+  height: T;
+};
+/**
+ * Hook options.
+ * @template InitializeWithValue - If `true` (default), the hook will initialize reading the window size. In SSR, you should set it to `false`, returning `undefined` initially.
+ */
+type UseWindowSizeOptions<InitializeWithValue extends boolean | undefined> = {
+  /**
+   * If `true` (default), the hook will initialize reading the window size. In SSR, you should set it to `false`, returning `undefined` initially.
+   * @default true
+   */
+  initializeWithValue: InitializeWithValue;
+  /**
+   * The delay in milliseconds before the state is updated (disabled by default for retro-compatibility).
+   * @default undefined
+   */
+  debounceDelay?: number;
+};
+declare function useWindowSize(options: UseWindowSizeOptions<false>): WindowSize;
+declare function useWindowSize(options?: Partial<UseWindowSizeOptions<true>>): WindowSize<number>;
+
+//#endregion
+export { ControlFunctions, CopiedValue, CopyFn, CountdownControllers, CountdownOptions, DOTS, DarkModeOptions, DarkModeReturn, DebouncedState, EventType, IntersectionReturn, MapOrEntries, Options, OriginalStyle, SetStepCallbackType, Size, TernaryDarkMode, TernaryDarkModeOptions, TernaryDarkModeReturn, UseAsyncState, UseBooleanReturn, UseCounterReturn, UseDebounceValueOptions, UseDocumentTitleOptions, UseIntersectionObserverOptions, UseIntersectionObserverState, UseListActions, UseListReturn, UseLocalStorageOptions, UseMapActions, UseMapReturn, UseMediaQueryOptions, UseResizeObserverOptions, UseScreenOptions, UseScriptOptions, UseScriptStatus, UseScrollLockOptions, UseScrollLockReturn, UseSessionStorageOptions, UseStepActions, UseWindowSizeOptions, WindowSize, useAsync, useBoolean, useClickAnyWhere, useCopyToClipboard, useCountdown, useCounter, useDarkMode, useDebounceCallback, useDebounceValue, useDisclosure, useDocumentTitle, useEventCallback, useEventListener, useGeolocation, useHover, useIdle, useIntersectionObserver, useInterval, useIsClient, useIsMounted, useIsomorphicLayoutEffect, useList, useLocalStorage, useMap, useMediaQuery, useMemoizedFn, useNetwork, useOnClickOutside, usePageLeave, usePagination, usePermission, usePrevious, useQueue, useReadLocalStorage, useResizeObserver, useScreen, useScript, useScrollLock, useSessionStorage, useSet, useStateList, useStep, useTernaryDarkMode, useThrottle, useThrottleFn, useTimeout, useToggle, useUnmount, useUpdate, useUpdateEffect, useWindowSize };