@mantine/hooks 8.0.1 → 8.1.0

package/lib/index.d.ts

@@ -1,5 +1,4 @@
 export * from './utils/index.js';
-export { useCallbackRef } from './use-callback-ref/use-callback-ref';
 export { useDebouncedCallback } from './use-debounced-callback/use-debounced-callback';
 export { useClickOutside } from './use-click-outside/use-click-outside';
 export { useClipboard } from './use-clipboard/use-clipboard';
@@ -71,12 +70,46 @@ export { useFetch } from './use-fetch/use-fetch';
 export { useRadialMove, normalizeRadialValue } from './use-radial-move/use-radial-move';
 export { useScrollSpy } from './use-scroll-spy/use-scroll-spy';
 export { useFileDialog } from './use-file-dialog/use-file-dialog';
-export type { UseMovePosition } from './use-move/use-move';
-export type { OS } from './use-os/use-os';
-export type { HotkeyItem, HotkeyItemOptions } from './use-hotkeys/use-hotkeys';
-export type { UseListStateHandlers } from './use-list-state/use-list-state';
-export type { EyeDropperOpenReturnType } from './use-eye-dropper/use-eye-dropper';
+export { useLongPress } from './use-long-press/use-long-press';
 export type { UseMediaQueryOptions } from './use-media-query/use-media-query';
-export type { UseStateHistoryHandlers, StateHistory } from './use-state-history/use-state-history';
-export type { UseFetchOptions } from './use-fetch/use-fetch';
+export type { UseClipboardOptions, UseClipboardReturnValue } from './use-clipboard/use-clipboard';
+export type { UseColorSchemeValue } from './use-color-scheme/use-color-scheme';
+export type { UseCounterOptions, UseCounterHandlers, UseCounterReturnValue, } from './use-counter/use-counter';
+export type { UseDebouncedCallbackOptions, UseDebouncedCallbackReturnValue, } from './use-debounced-callback/use-debounced-callback';
+export type { UseDebouncedStateOptions, UseDebouncedStateReturnValue, } from './use-debounced-state/use-debounced-state';
+export type { UseDebouncedValueOptions, UseDebouncedValueReturnValue, } from './use-debounced-value/use-debounced-value';
+export type { UseDisclosureOptions, UseDisclosureHandlers, UseDisclosureReturnValue, } from './use-disclosure/use-disclosure';
+export type { EyeDropperOpenOptions, EyeDropperOpenReturnType, UseEyeDropperReturnValue, } from './use-eye-dropper/use-eye-dropper';
+export type { UseFetchOptions, UseFetchReturnValue } from './use-fetch/use-fetch';
+export type { UseFileDialogOptions, UseFileDialogReturnValue, } from './use-file-dialog/use-file-dialog';
+export type { UseFocusReturnOptions, UseFocusReturnReturnValue, } from './use-focus-return/use-focus-return';
+export type { UseFocusWithinOptions, UseFocusWithinReturnValue, } from './use-focus-within/use-focus-within';
+export type { UseFullscreenReturnValue } from './use-fullscreen/use-fullscreen';
+export type { UseHashOptions, UseHashReturnValue } from './use-hash/use-hash';
+export type { UseHeadroomOptions } from './use-headroom/use-headroom';
+export type { HotkeyItemOptions, HotkeyItem } from './use-hotkeys/use-hotkeys';
+export type { UseHoverReturnValue } from './use-hover/use-hover';
+export type { UseIdleOptions } from './use-idle/use-idle';
+export type { UseInViewportReturnValue } from './use-in-viewport/use-in-viewport';
+export type { UseInputStateReturnValue } from './use-input-state/use-input-state';
+export type { UseIntersectionReturnValue } from './use-intersection/use-intersection';
+export type { UseIntervalOptions, UseIntervalReturnValue } from './use-interval/use-interval';
+export type { UseListStateReturnValue, UseListStateHandlers, } from './use-list-state/use-list-state';
+export type { UseStorageOptions, UseStorageReturnValue } from './use-local-storage/create-storage';
+export type { UseMovePosition, UseMoveHandlers, UseMoveReturnValue } from './use-move/use-move';
+export type { UserNetworkReturnValue } from './use-network/use-network';
+export type { UseOrientationOptions, UseOrientationReturnType, } from './use-orientation/use-orientation';
+export type { UseOSReturnValue as OS, UseOSReturnValue, UseOsOptions } from './use-os/use-os';
+export type { UsePaginationOptions, UsePaginationReturnValue, } from './use-pagination/use-pagination';
+export type { UseQueueOptions, UseQueueReturnValue } from './use-queue/use-queue';
+export type { UseRadialMoveOptions, UseRadialMoveReturnValue, } from './use-radial-move/use-radial-move';
+export type { UseScrollIntoViewOptions, UseScrollIntoViewReturnValue, } from './use-scroll-into-view/use-scroll-into-view';
 export type { UseScrollSpyOptions, UseScrollSpyHeadingData, UseScrollSpyReturnType, } from './use-scroll-spy/use-scroll-spy';
+export type { UseSetStateCallback, UseSetStateReturnValue } from './use-set-state/use-set-state';
+export type { UseStateHistoryHandlers, UseStateHistoryValue as StateHistory, UseStateHistoryValue, UseStateHistoryReturnValue, } from './use-state-history/use-state-history';
+export type { UseTimeoutOptions, UseTimeoutReturnValue } from './use-timeout/use-timeout';
+export type { UseToggleReturnValue } from './use-toggle/use-toggle';
+export type { UseUncontrolledOptions, UseUncontrolledReturnValue, } from './use-uncontrolled/use-uncontrolled';
+export type { UseValidatedStateValue, UseValidatedStateReturnValue, } from './use-validated-state/use-validated-state';
+export type { UseWindowScrollPosition, UseWindowScrollTo, UseWindowScrollReturnValue, } from './use-window-scroll/use-window-scroll';
+export type { UseLongPressOptions, UseLongPressReturnValue } from './use-long-press/use-long-press';

package/lib/use-clipboard/use-clipboard.d.ts

@@ -1,8 +1,15 @@
-export declare function useClipboard({ timeout }?: {
-    timeout?: number | undefined;
-}): {
-    copy: (valueToCopy: any) => void;
+export interface UseClipboardOptions {
+    /** Time in ms after which the copied state will reset, `2000` by default */
+    timeout?: number;
+}
+export interface UseClipboardReturnValue {
+    /** Function to copy value to clipboard */
+    copy: (value: any) => void;
+    /** Function to reset copied state and error */
     reset: () => void;
+    /** Error if copying failed */
     error: Error | null;
+    /** Boolean indicating if the value was copied successfully */
     copied: boolean;
-};
+}
+export declare function useClipboard(options?: UseClipboardOptions): UseClipboardReturnValue;

package/lib/use-color-scheme/use-color-scheme.d.ts

@@ -1,2 +1,3 @@
 import { UseMediaQueryOptions } from '../use-media-query/use-media-query';
-export declare function useColorScheme(initialValue?: 'dark' | 'light', options?: UseMediaQueryOptions): "dark" | "light";
+export type UseColorSchemeValue = 'dark' | 'light';
+export declare function useColorScheme(initialValue?: UseColorSchemeValue, options?: UseMediaQueryOptions): UseColorSchemeValue;

package/lib/use-counter/use-counter.d.ts

@@ -1,9 +1,12 @@
-export declare function useCounter(initialValue?: number, options?: Partial<{
-    min: number;
-    max: number;
-}>): readonly [number, {
-    readonly increment: () => void;
-    readonly decrement: () => void;
-    readonly set: (value: number) => void;
-    readonly reset: () => void;
-}];
+export interface UseCounterOptions {
+    min?: number;
+    max?: number;
+}
+export interface UseCounterHandlers {
+    increment: () => void;
+    decrement: () => void;
+    set: (value: number) => void;
+    reset: () => void;
+}
+export type UseCounterReturnValue = [number, UseCounterHandlers];
+export declare function useCounter(initialValue?: number, options?: UseCounterOptions): [number, UseCounterHandlers];

package/lib/use-debounced-callback/use-debounced-callback.d.ts

@@ -1,7 +1,11 @@
-export declare function useDebouncedCallback<T extends (...args: any[]) => any>(callback: T, options: number | {
+export interface UseDebouncedCallbackOptions {
     delay: number;
     flushOnUnmount?: boolean;
     leading?: boolean;
-}): ((...args: Parameters<T>) => void) & {
+}
+export type UseDebouncedCallbackReturnValue<T extends (...args: any[]) => any> = ((...args: Parameters<T>) => void) & {
+    flush: () => void;
+};
+export declare function useDebouncedCallback<T extends (...args: any[]) => any>(callback: T, options: number | UseDebouncedCallbackOptions): ((...args: Parameters<T>) => void) & {
     flush: () => void;
 };

package/lib/use-debounced-state/use-debounced-state.d.ts

@@ -1,4 +1,6 @@
 import { SetStateAction } from 'react';
-export declare function useDebouncedState<T = any>(defaultValue: T, wait: number, options?: {
-    leading: boolean;
-}): readonly [T, (newValue: SetStateAction<T>) => void];
+export interface UseDebouncedStateOptions {
+    leading?: boolean;
+}
+export type UseDebouncedStateReturnValue<T> = [T, (newValue: SetStateAction<T>) => void];
+export declare function useDebouncedState<T = any>(defaultValue: T, wait: number, options?: UseDebouncedStateOptions): UseDebouncedStateReturnValue<T>;

package/lib/use-debounced-value/use-debounced-value.d.ts

@@ -1,3 +1,5 @@
-export declare function useDebouncedValue<T = any>(value: T, wait: number, options?: {
-    leading: boolean;
-}): readonly [T, () => void];
+export interface UseDebouncedValueOptions {
+    leading?: boolean;
+}
+export type UseDebouncedValueReturnValue<T> = [T, () => void];
+export declare function useDebouncedValue<T = any>(value: T, wait: number, options?: UseDebouncedValueOptions): UseDebouncedValueReturnValue<T>;

package/lib/use-disclosure/use-disclosure.d.ts

@@ -1,8 +1,11 @@
-export declare function useDisclosure(initialState?: boolean, callbacks?: {
+export interface UseDisclosureOptions {
     onOpen?: () => void;
     onClose?: () => void;
-}): readonly [boolean, {
-    readonly open: () => void;
-    readonly close: () => void;
-    readonly toggle: () => void;
-}];
+}
+export interface UseDisclosureHandlers {
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+export type UseDisclosureReturnValue = [boolean, UseDisclosureHandlers];
+export declare function useDisclosure(initialState?: boolean, options?: UseDisclosureOptions): UseDisclosureReturnValue;

package/lib/use-event-listener/use-event-listener.d.ts

@@ -1 +1 @@
-export declare function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement = any>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): import("react").RefObject<T | null>;
+export declare function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement = any>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): React.RefCallback<T | null>;

package/lib/use-eye-dropper/use-eye-dropper.d.ts

@@ -1,11 +1,11 @@
-interface EyeDropperOpenOptions {
+export interface EyeDropperOpenOptions {
     signal?: AbortSignal;
 }
 export interface EyeDropperOpenReturnType {
     sRGBHex: string;
 }
-export declare function useEyeDropper(): {
+export interface UseEyeDropperReturnValue {
     supported: boolean;
     open: (options?: EyeDropperOpenOptions) => Promise<EyeDropperOpenReturnType | undefined>;
-};
-export {};
+}
+export declare function useEyeDropper(): UseEyeDropperReturnValue;

package/lib/use-fetch/use-fetch.d.ts

@@ -1,10 +1,11 @@
 export interface UseFetchOptions extends RequestInit {
     autoInvoke?: boolean;
 }
-export declare function useFetch<T>(url: string, { autoInvoke, ...options }?: UseFetchOptions): {
+export interface UseFetchReturnValue<T> {
     data: T | null;
     loading: boolean;
     error: Error | null;
-    refetch: () => Promise<any> | undefined;
+    refetch: () => Promise<any>;
     abort: () => void;
-};
+}
+export declare function useFetch<T>(url: string, { autoInvoke, ...options }?: UseFetchOptions): UseFetchReturnValue<T>;

package/lib/use-file-dialog/use-file-dialog.d.ts

@@ -16,8 +16,9 @@ export interface UseFileDialogOptions {
     /** Called when file dialog is canceled */
     onCancel?: () => void;
 }
-export declare function useFileDialog(input?: UseFileDialogOptions): {
+export interface UseFileDialogReturnValue {
     files: FileList | null;
     open: () => void;
     reset: () => void;
-};
+}
+export declare function useFileDialog(input?: UseFileDialogOptions): UseFileDialogReturnValue;

package/lib/use-focus-return/use-focus-return.d.ts

@@ -1,7 +1,6 @@
-interface UseFocusReturn {
+export interface UseFocusReturnOptions {
     opened: boolean;
     shouldReturnFocus?: boolean;
 }
-/** Returns focus to last active element, used in Modal and Drawer */
-export declare function useFocusReturn({ opened, shouldReturnFocus }: UseFocusReturn): () => void;
-export {};
+export type UseFocusReturnReturnValue = () => void;
+export declare function useFocusReturn({ opened, shouldReturnFocus, }: UseFocusReturnOptions): UseFocusReturnReturnValue;

package/lib/use-focus-trap/use-focus-trap.d.ts

@@ -1 +1 @@
-export declare function useFocusTrap(active?: boolean): (instance: HTMLElement | null) => void;
+export declare function useFocusTrap(active?: boolean): React.RefCallback<HTMLElement | null>;

package/lib/use-focus-within/use-focus-within.d.ts

@@ -2,7 +2,8 @@ export interface UseFocusWithinOptions {
     onFocus?: (event: FocusEvent) => void;
     onBlur?: (event: FocusEvent) => void;
 }
-export declare function useFocusWithin<T extends HTMLElement = any>({ onBlur, onFocus, }?: UseFocusWithinOptions): {
-    ref: React.RefObject<T>;
+export interface UseFocusWithinReturnValue<T extends HTMLElement = any> {
+    ref: React.RefCallback<T | null>;
     focused: boolean;
-};
+}
+export declare function useFocusWithin<T extends HTMLElement = any>({ onBlur, onFocus, }?: UseFocusWithinOptions): UseFocusWithinReturnValue<T>;

package/lib/use-fullscreen/use-fullscreen.d.ts

@@ -1,5 +1,6 @@
-export declare function useFullscreen<T extends HTMLElement = any>(): {
-    readonly ref: (element: T | null) => void;
-    readonly toggle: () => Promise<void>;
-    readonly fullscreen: boolean;
-};
+export interface UseFullscreenReturnValue<T extends HTMLElement = any> {
+    ref: React.RefCallback<T | null>;
+    toggle: () => Promise<void>;
+    fullscreen: boolean;
+}
+export declare function useFullscreen<T extends HTMLElement = any>(): UseFullscreenReturnValue<T>;

package/lib/use-hash/use-hash.d.ts

@@ -1,5 +1,5 @@
-interface UseHashOptions {
+export interface UseHashOptions {
     getInitialValueInEffect?: boolean;
 }
-export declare function useHash({ getInitialValueInEffect }?: UseHashOptions): readonly [string, (value: string) => void];
-export {};
+export type UseHashReturnValue = [string, (value: string) => void];
+export declare function useHash({ getInitialValueInEffect, }?: UseHashOptions): UseHashReturnValue;

package/lib/use-headroom/use-headroom.d.ts

@@ -1,9 +1,9 @@
 export declare const isFixed: (current: number, fixedAt: number) => boolean;
 export declare const isPinned: (current: number, previous: number) => boolean;
 export declare const isReleased: (current: number, previous: number, fixedAt: number) => boolean;
-export declare const isPinnedOrReleased: (current: number, fixedAt: number, isCurrentlyPinnedRef: React.MutableRefObject<boolean>, isScrollingUp: boolean, onPin?: () => void, onRelease?: () => void) => void;
+export declare const isPinnedOrReleased: (current: number, fixedAt: number, isCurrentlyPinnedRef: React.RefObject<boolean>, isScrollingUp: boolean, onPin?: () => void, onRelease?: () => void) => void;
 export declare const useScrollDirection: () => boolean;
-interface UseHeadroomInput {
+export interface UseHeadroomOptions {
     /** Number in px at which element should be fixed */
     fixedAt?: number;
     /** Called when element is pinned */
@@ -13,5 +13,4 @@ interface UseHeadroomInput {
     /** Called when element is unpinned */
     onRelease?: () => void;
 }
-export declare function useHeadroom({ fixedAt, onPin, onFix, onRelease }?: UseHeadroomInput): boolean;
-export {};
+export declare function useHeadroom({ fixedAt, onPin, onFix, onRelease }?: UseHeadroomOptions): boolean;

package/lib/use-hover/use-hover.d.ts

@@ -1,4 +1,5 @@
-export declare function useHover<T extends HTMLElement = any>(): {
-    ref: import("react").RefObject<T | null>;
+export interface UseHoverReturnValue<T extends HTMLElement = any> {
     hovered: boolean;
-};
+    ref: React.RefCallback<T | null>;
+}
+export declare function useHover<T extends HTMLElement = any>(): UseHoverReturnValue<T>;

package/lib/use-idle/use-idle.d.ts

@@ -1,4 +1,5 @@
-export declare function useIdle(timeout: number, options?: Partial<{
-    events: (keyof DocumentEventMap)[];
-    initialState: boolean;
-}>): boolean;
+export interface UseIdleOptions {
+    events?: (keyof DocumentEventMap)[];
+    initialState?: boolean;
+}
+export declare function useIdle(timeout: number, options?: UseIdleOptions): boolean;

package/lib/use-in-viewport/use-in-viewport.d.ts

@@ -1,4 +1,5 @@
-export declare function useInViewport<T extends HTMLElement = any>(): {
-    ref: (node: T | null) => void;
+export interface UseInViewportReturnValue<T extends HTMLElement = any> {
     inViewport: boolean;
-};
+    ref: React.RefCallback<T | null>;
+}
+export declare function useInViewport<T extends HTMLElement = any>(): UseInViewportReturnValue<T>;

package/lib/use-input-state/use-input-state.d.ts

@@ -1,2 +1,6 @@
 export declare function getInputOnChange<T>(setValue: (value: null | undefined | T | ((current: T) => T)) => void): (val: null | undefined | T | React.ChangeEvent<any> | ((current: T) => T)) => void;
-export declare function useInputState<T>(initialState: T): [T, (value: null | undefined | T | React.ChangeEvent<any>) => void];
+export type UseInputStateReturnValue<T> = [
+    T,
+    (value: null | undefined | T | React.ChangeEvent<any>) => void
+];
+export declare function useInputState<T>(initialState: T): UseInputStateReturnValue<T>;

package/lib/use-intersection/use-intersection.d.ts

@@ -1,4 +1,5 @@
-export declare function useIntersection<T extends HTMLElement = any>(options?: ConstructorParameters<typeof IntersectionObserver>[1]): {
-    ref: (element: T | null) => void;
+export interface UseIntersectionReturnValue<T> {
+    ref: React.RefCallback<T | null>;
     entry: IntersectionObserverEntry | null;
-};
+}
+export declare function useIntersection<T extends HTMLElement = any>(options?: IntersectionObserverInit): UseIntersectionReturnValue<T>;

package/lib/use-interval/use-interval.d.ts

@@ -1,11 +1,15 @@
-interface UseIntervalOptions {
+export interface UseIntervalOptions {
     /** If set, the interval will start automatically when the component is mounted, `false` by default */
     autoInvoke?: boolean;
 }
-export declare function useInterval(fn: () => void, interval: number, { autoInvoke }?: UseIntervalOptions): {
+export interface UseIntervalReturnValue {
+    /** Starts the interval */
     start: () => void;
+    /** Stops the interval */
     stop: () => void;
+    /** Toggles the interval */
     toggle: () => void;
+    /** Indicates if the interval is active */
     active: boolean;
-};
-export {};
+}
+export declare function useInterval(fn: () => void, interval: number, { autoInvoke }?: UseIntervalOptions): UseIntervalReturnValue;

package/lib/use-list-state/use-list-state.d.ts

@@ -20,5 +20,5 @@ export interface UseListStateHandlers<T> {
     setItemProp: <K extends keyof T, U extends T[K]>(index: number, prop: K, value: U) => void;
     filter: (fn: (item: T, i: number) => boolean) => void;
 }
-export type UseListState<T> = [T[], UseListStateHandlers<T>];
-export declare function useListState<T>(initialValue?: T[]): UseListState<T>;
+export type UseListStateReturnValue<T> = [T[], UseListStateHandlers<T>];
+export declare function useListState<T>(initialValue?: T[]): UseListStateReturnValue<T>;

package/lib/use-local-storage/create-storage.d.ts

@@ -1,5 +1,5 @@
 export type StorageType = 'localStorage' | 'sessionStorage';
-export interface StorageProperties<T> {
+export interface UseStorageOptions<T> {
     /** Storage key */
     key: string;
     /** Default value that will be set if value is not found in storage */
@@ -13,5 +13,10 @@ export interface StorageProperties<T> {
     /** Function to deserialize string value from storage to value */
     deserialize?: (value: string | undefined) => T;
 }
-export declare function createStorage<T>(type: StorageType, hookName: string): ({ key, defaultValue, getInitialValueInEffect, sync, deserialize, serialize, }: StorageProperties<T>) => [T, (val: T | ((prevState: T) => T)) => void, () => void];
-export declare function readValue(type: StorageType): <T>({ key, defaultValue, deserialize, }: StorageProperties<T>) => T;
+export type UseStorageReturnValue<T> = [
+    T,
+    (val: T | ((prevState: T) => T)) => void,
+    () => void
+];
+export declare function createStorage<T>(type: StorageType, hookName: string): ({ key, defaultValue, getInitialValueInEffect, sync, deserialize, serialize, }: UseStorageOptions<T>) => UseStorageReturnValue<T>;
+export declare function readValue(type: StorageType): <T>({ key, defaultValue, deserialize, }: UseStorageOptions<T>) => T;

package/lib/use-local-storage/use-local-storage.d.ts

@@ -1,3 +1,3 @@
-import { StorageProperties } from './create-storage';
-export declare function useLocalStorage<T = string>(props: StorageProperties<T>): [T, (val: T | ((prevState: T) => T)) => void, () => void];
-export declare const readLocalStorageValue: <T>({ key, defaultValue, deserialize, }: StorageProperties<T>) => T;
+import { UseStorageOptions } from './create-storage';
+export declare function useLocalStorage<T = string>(props: UseStorageOptions<T>): import("./create-storage").UseStorageReturnValue<T>;
+export declare const readLocalStorageValue: <T>({ key, defaultValue, deserialize, }: UseStorageOptions<T>) => T;

package/lib/use-long-press/use-long-press.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+export interface UseLongPressOptions {
+    /** Time in milliseconds to trigger the long press, default is 400ms */
+    threshold?: number;
+    /** Callback triggered when the long press starts */
+    onStart?: (event: React.MouseEvent | React.TouchEvent) => void;
+    /** Callback triggered when the long press finishes */
+    onFinish?: (event: React.MouseEvent | React.TouchEvent) => void;
+    /** Callback triggered when the long press is canceled */
+    onCancel?: (event: React.MouseEvent | React.TouchEvent) => void;
+}
+export interface UseLongPressReturnValue {
+    onMouseDown: (event: React.MouseEvent) => void;
+    onMouseUp: (event: React.MouseEvent) => void;
+    onMouseLeave: (event: React.MouseEvent) => void;
+    onTouchStart: (event: React.TouchEvent) => void;
+    onTouchEnd: (event: React.TouchEvent) => void;
+}
+export declare function useLongPress(onLongPress: (event: React.MouseEvent | React.TouchEvent) => void, options?: UseLongPressOptions): UseLongPressReturnValue;

package/lib/use-media-query/use-media-query.d.ts

@@ -1,4 +1,4 @@
 export interface UseMediaQueryOptions {
     getInitialValueInEffect: boolean;
 }
-export declare function useMediaQuery(query: string, initialValue?: boolean, { getInitialValueInEffect }?: UseMediaQueryOptions): boolean | undefined;
+export declare function useMediaQuery(query: string, initialValue?: boolean, { getInitialValueInEffect }?: UseMediaQueryOptions): boolean;

package/lib/use-merged-ref/use-merged-ref.d.ts

@@ -2,6 +2,6 @@ import { Ref, type RefCallback } from 'react';
 type PossibleRef<T> = Ref<T> | undefined;
 type RefCleanup<T> = ReturnType<RefCallback<T>>;
 export declare function assignRef<T>(ref: PossibleRef<T>, value: T): RefCleanup<T>;
-export declare function mergeRefs<T>(...refs: PossibleRef<T>[]): (node: T | null) => (() => void) | undefined;
-export declare function useMergedRef<T>(...refs: PossibleRef<T>[]): (node: T | null) => (() => void) | undefined;
+export declare function mergeRefs<T>(...refs: PossibleRef<T>[]): RefCallback<T>;
+export declare function useMergedRef<T>(...refs: PossibleRef<T>[]): RefCallback<T>;
 export {};

package/lib/use-move/use-move.d.ts

@@ -6,12 +6,12 @@ export declare function clampUseMovePosition(position: UseMovePosition): {
     x: number;
     y: number;
 };
-interface useMoveHandlers {
+export interface UseMoveHandlers {
     onScrubStart?: () => void;
     onScrubEnd?: () => void;
 }
-export declare function useMove<T extends HTMLElement = any>(onChange: (value: UseMovePosition) => void, handlers?: useMoveHandlers, dir?: 'ltr' | 'rtl'): {
-    ref: import("react").RefObject<T | null>;
+export interface UseMoveReturnValue<T extends HTMLElement = any> {
+    ref: React.RefCallback<T | null>;
     active: boolean;
-};
-export {};
+}
+export declare function useMove<T extends HTMLElement = any>(onChange: (value: UseMovePosition) => void, handlers?: UseMoveHandlers, dir?: 'ltr' | 'rtl'): UseMoveReturnValue<T>;

package/lib/use-network/use-network.d.ts

@@ -1,4 +1,5 @@
-interface NetworkStatus {
+export interface UserNetworkReturnValue {
+    online: boolean;
     downlink?: number;
     downlinkMax?: number;
     effectiveType?: 'slow-2g' | '2g' | '3g' | '4g';
@@ -6,7 +7,4 @@ interface NetworkStatus {
     saveData?: boolean;
     type?: 'bluetooth' | 'cellular' | 'ethernet' | 'wifi' | 'wimax' | 'none' | 'other' | 'unknown';
 }
-export declare function useNetwork(): {
-    online: boolean;
-} & NetworkStatus;
-export {};
+export declare function useNetwork(): UserNetworkReturnValue;

package/lib/use-orientation/use-orientation.d.ts

@@ -1,4 +1,4 @@
-interface UseOrientationOptions {
+export interface UseOrientationOptions {
     /** Default angle value, used until the real can be retrieved
      * (during server side rendering and before js executes on the page)
      * If not provided, the default value is `0`
@@ -15,9 +15,8 @@ interface UseOrientationOptions {
      */
     getInitialValueInEffect?: boolean;
 }
-interface UseOrientationReturnType {
+export interface UseOrientationReturnType {
     angle: number;
     type: OrientationType;
 }
 export declare function useOrientation({ defaultAngle, defaultType, getInitialValueInEffect, }?: UseOrientationOptions): UseOrientationReturnType;
-export {};

package/lib/use-os/use-os.d.ts

@@ -1,6 +1,5 @@
-export type OS = 'undetermined' | 'macos' | 'ios' | 'windows' | 'android' | 'linux' | 'chromeos';
-interface UseOsOptions {
+export type UseOSReturnValue = 'undetermined' | 'macos' | 'ios' | 'windows' | 'android' | 'linux' | 'chromeos';
+export interface UseOsOptions {
     getValueInEffect: boolean;
 }
-export declare function useOs(options?: UseOsOptions): OS;
-export {};
+export declare function useOs(options?: UseOsOptions): UseOSReturnValue;

package/lib/use-pagination/use-pagination.d.ts

@@ -1,5 +1,5 @@
 export declare const DOTS = "dots";
-export interface PaginationParams {
+export interface UsePaginationOptions {
     /** Page selected on initial render, defaults to 1 */
     initialPage?: number;
     /** Controlled active page number */
@@ -13,12 +13,20 @@ export interface PaginationParams {
     /** Callback fired after change of each page */
     onChange?: (page: number) => void;
 }
-export declare function usePagination({ total, siblings, boundaries, page, initialPage, onChange, }: PaginationParams): {
-    range: (number | "dots")[];
+export interface UsePaginationReturnValue {
+    /** Array of page numbers and dots */
+    range: (number | 'dots')[];
+    /** Active page number */
     active: number;
-    setPage: (pageNumber: number) => void;
+    /** Function to set active page */
+    setPage: (page: number) => void;
+    /** Function to go to next page */
     next: () => void;
+    /** Function to go to previous page */
     previous: () => void;
+    /** Function to go to first page */
     first: () => void;
+    /** Function to go to last page */
     last: () => void;
-};
+}
+export declare function usePagination({ total, siblings, boundaries, page, initialPage, onChange, }: UsePaginationOptions): UsePaginationReturnValue;

package/lib/use-queue/use-queue.d.ts

@@ -1,10 +1,19 @@
-export declare function useQueue<T>({ initialValues, limit }: {
+export interface UseQueueOptions<T> {
+    /** Initial values to be added to the queue */
     initialValues?: T[];
+    /** Maximum number of items in the state */
     limit: number;
-}): {
-    state: T[];
+}
+export interface UseQueueReturnValue<T> {
+    /** Array of items in the queue */
     queue: T[];
+    /** Array of items in the state */
+    state: T[];
+    /** Function to add items to state or queue */
     add: (...items: T[]) => void;
+    /** Function to apply updates to current items */
     update: (fn: (state: T[]) => T[]) => void;
+    /** Function to clear the queue */
     cleanQueue: () => void;
-};
+}
+export declare function useQueue<T>({ initialValues, limit, }: UseQueueOptions<T>): UseQueueReturnValue<T>;

package/lib/use-radial-move/use-radial-move.d.ts

@@ -9,7 +9,10 @@ export interface UseRadialMoveOptions {
     /** Called in `onMouseUp` and `onTouchEnd` events */
     onScrubEnd?: () => void;
 }
-export declare function useRadialMove<T extends HTMLElement = any>(onChange: (value: number) => void, { step, onChangeEnd, onScrubStart, onScrubEnd }?: UseRadialMoveOptions): {
-    ref: import("react").RefObject<T | null>;
+export interface UseRadialMoveReturnValue<T extends HTMLElement = any> {
+    /** Ref to be passed to the element that should be used for radial move */
+    ref: React.RefCallback<T | null>;
+    /** Indicates whether the radial move is active */
     active: boolean;
-};
+}
+export declare function useRadialMove<T extends HTMLElement = any>(onChange: (value: number) => void, { step, onChangeEnd, onScrubStart, onScrubEnd }?: UseRadialMoveOptions): UseRadialMoveReturnValue<T>;

package/lib/use-reduced-motion/use-reduced-motion.d.ts

@@ -1,2 +1,2 @@
 import { UseMediaQueryOptions } from '../use-media-query/use-media-query';
-export declare function useReducedMotion(initialValue?: boolean, options?: UseMediaQueryOptions): boolean | undefined;
+export declare function useReducedMotion(initialValue?: boolean, options?: UseMediaQueryOptions): boolean;

package/lib/use-scroll-into-view/use-scroll-into-view.d.ts

@@ -1,8 +1,8 @@
-interface ScrollIntoViewAnimation {
+interface UseScrollIntoViewAnimation {
     /** Target element alignment relatively to parent based on current axis */
     alignment?: 'start' | 'end' | 'center';
 }
-interface ScrollIntoViewParams {
+export interface UseScrollIntoViewOptions {
     /** Callback fired after scroll */
     onScrollFinish?: () => void;
     /** Duration of scroll in milliseconds */
@@ -18,11 +18,11 @@ interface ScrollIntoViewParams {
     /** Prevents content jumping in scrolling lists with multiple targets */
     isList?: boolean;
 }
-interface ScrollIntoViewReturnType<Target extends HTMLElement = any, Parent extends HTMLElement | null = null> {
-    scrollableRef: React.RefObject<Parent>;
-    targetRef: React.RefObject<Target>;
-    scrollIntoView: (params?: ScrollIntoViewAnimation) => void;
+export interface UseScrollIntoViewReturnValue<Target extends HTMLElement = any, Parent extends HTMLElement | null = null> {
+    scrollableRef: React.RefObject<Parent | null>;
+    targetRef: React.RefObject<Target | null>;
+    scrollIntoView: (params?: UseScrollIntoViewAnimation) => void;
     cancel: () => void;
 }
-export declare function useScrollIntoView<Target extends HTMLElement = any, Parent extends HTMLElement | null = null>({ duration, axis, onScrollFinish, easing, offset, cancelable, isList, }?: ScrollIntoViewParams): ScrollIntoViewReturnType<Target, Parent>;
+export declare function useScrollIntoView<Target extends HTMLElement = any, Parent extends HTMLElement | null = null>({ duration, axis, onScrollFinish, easing, offset, cancelable, isList, }?: UseScrollIntoViewOptions): UseScrollIntoViewReturnValue<Target, Parent>;
 export {};