@siberiacancode/reactuse 0.0.111 → 0.0.113

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

@@ -0,0 +1,68 @@
+/** The use offset pagination return type */
+export interface UseOffsetPaginationOptions {
+    /** The initial page number */
+    initialPage?: number;
+    /** The number of items per page */
+    pageSize?: number;
+    /** The total number of items */
+    total?: number;
+    /** The callback function to be invoked when page changes */
+    onPageChange?: ({ page, pageSize }: {
+        page: number;
+        pageSize: number;
+    }) => void;
+    /** The callback function to be invoked when page count changes */
+    onPageCountChange?: ({ page, pageSize }: {
+        page: number;
+        pageSize: number;
+    }) => void;
+    /** The callback function to be invoked when page size changes */
+    onPageSizeChange?: ({ page, pageSize }: {
+        page: number;
+        pageSize: number;
+    }) => void;
+}
+/** The use offset pagination return type */
+export interface UseOffsetPaginationReturn {
+    /** The number of items per page */
+    currentPageSize: number;
+    /** Whether the current page is the first page */
+    isFirstPage: boolean;
+    /** Whether the current page is the last page */
+    isLastPage: boolean;
+    /** The current page number */
+    page: number;
+    /** The total number of pages */
+    pageCount: number;
+    /** The callback function to go to the next page */
+    next: () => void;
+    /** The callback function to go to the previous page */
+    prev: () => void;
+    /** The callback function to set the current page */
+    set: (page: number) => void;
+}
+/**
+ * @name useOffsetPagination
+ * @description - Hook that defines the logic when pagination
+ * @category Utilities
+ *
+ * @param {UseOffsetPaginationOptions} options - The options for the hook
+ * @param {number} [options.total] - The total number of items
+ * @param {number} [options.pageSize] - The number of items per page
+ * @param {number} [options.initialPage] - The current page
+ * @param {({ page, pageSize }: { page: number; pageSize: number }) => void} [options.onPageChange] - The callback function to be invoked when page changes
+ * @param {({ page, pageSize }: { page: number; pageSize: number }) => void} [options.onPageCountChange] - The callback function to be invoked when page count changes
+ * @param {({ page, pageSize }: { page: number; pageSize: number }) => void} [options.onPageSizeChange] - The callback function to be invoked when page size changes
+ * @returns {UseOffsetPaginationReturn} - The state of the hook
+ *
+ * @example
+ * const { currentPage, currentPageSize, pageCount, isFirstPage, isLastPage, prev, next } = useOffsetPagination({
+ *  total: 100,
+ *  pageSize: 10,
+ *  page: 1,
+ *  onPageChange: (page) => {},
+ *  onPageCountChange: (pageCount) => {},
+ *  onPageSizeChange: (pageSize) => {}
+ * });
+ */
+export declare const useOffsetPagination: ({ total, pageSize, initialPage, onPageChange, onPageCountChange, onPageSizeChange }?: UseOffsetPaginationOptions) => UseOffsetPaginationReturn;

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

@@ -0,0 +1,14 @@
+import { EffectCallback } from 'react';
+/**
+ * @name useEffectOnce
+ * @description - Hook that runs an effect only once. Please do not use it in production code!
+ * @category Humor
+ *
+ * @warning - This hook will run effect only once even in strict mode. Please do not use it in production code!
+ *
+ * @param {EffectCallback} effect The effect to run
+ *
+ * @example
+ * useOnce(() => console.log('effect once'));
+ */
+export declare function useOnce(effect: EffectCallback): void;

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

@@ -0,0 +1,13 @@
+/**
+ * @name useOnline
+ * @description - Hook that manages if the user is online
+ * @category Sensors
+ *
+ * @browserapi navigator.onLine https://developer.mozilla.org/en-US/docs/Web/API/Navigator/onLine
+ *
+ * @returns {boolean} A boolean indicating if the user is online
+ *
+ * @example
+ * const online = useOnline();
+ */
+export declare const useOnline: () => boolean;

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

@@ -0,0 +1,14 @@
+/** The operating system type */
+export type OperatingSystem = 'android' | 'ios' | 'linux' | 'macos' | 'undetermined' | 'windows';
+export declare const getOperatingSystem: () => OperatingSystem;
+/**
+ * @name useOperatingSystem
+ * @description - Hook that returns the operating system of the current browser
+ * @category Browser
+ *
+ * @returns {OperatingSystem} The operating system
+ *
+ * @example
+ * const operatingSystem = useOperatingSystem();
+ */
+export declare const useOperatingSystem: () => OperatingSystem;

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

@@ -0,0 +1,18 @@
+export type UseOptimisticReturn<State> = [
+    State,
+    (optimisticValue: State, promise: Promise<any>) => void
+];
+/**
+ * @name useOptimistic
+ * @description - Hook that allows get optimistic value before its update
+ * @category Utilities
+ *
+ * @template State The type of the state
+ * @param {State} state The value to be returned initially and whenever no action is pending
+ * @param {(currentState: State, optimisticValue: State) => State} update A pure function that takes the current state and the optimistic value passed to updateOptimistic and returns the resulting optimistic state
+ * @returns {UseOptimisticReturn<State>} The resulting optimistic state, and the function to update it
+ *
+ * @example
+ * const [optimisticValue, updateOptimistic] = useOptimistic<number>(count, (currentState, optimisticValue) => currentState + optimisticValue);
+ */
+export declare const useOptimistic: <State, OptimisticState = State>(externalState: State, update: (currentState: State, optimisticState: OptimisticState) => State) => readonly [State, (optimisticValue: OptimisticState, promise: Promise<any>) => Promise<any>];

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

@@ -0,0 +1,20 @@
+/** The use orientation return type */
+export interface UseOrientationReturn {
+    /** The current screen orientation angle */
+    angle: number;
+    /** The screen orientation type */
+    type: OrientationType;
+}
+/**
+ * @name useOrientation
+ * @description - Hook that returns the current screen orientation
+ * @category Browser
+ *
+ * @browserapi window.screen.orientation https://developer.mozilla.org/en-US/docs/Web/API/Screen/orientation
+ *
+ * @returns {UseOrientationReturn} An object containing the current screen orientation
+ *
+ * @example
+ * const { angle, type } = useOrientation();
+ */
+export declare const useOrientation: () => UseOrientationReturn;

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

@@ -0,0 +1,49 @@
+declare global {
+    interface OTPOptions {
+        readonly transport: string[];
+    }
+    interface CredentialRequestOptions {
+        readonly otp: OTPOptions;
+    }
+    interface Credential {
+        readonly code: string;
+    }
+}
+export type UseOtpCredentialCallback = (otp: Credential | null) => void;
+export interface UseOtpCredentialParams {
+    onError: (error: any) => void;
+    onSuccess: (credential: Credential | null) => void;
+}
+export interface UseOtpCredentialReturn {
+    abort: AbortController['abort'];
+    aborted: boolean;
+    supported: boolean;
+    get: () => Promise<Credential | null>;
+}
+export interface UseOtpCredential {
+    (callback?: UseOtpCredentialCallback): UseOtpCredentialReturn;
+    (params?: UseOtpCredentialParams): UseOtpCredentialReturn;
+}
+/**
+ * @name useOtpCredential
+ * @description - Hook that creates an otp credential
+ * @category Browser
+ *
+ * @browserapi navigator.credentials https://developer.mozilla.org/en-US/docs/Web/API/Navigator/credentials
+ *
+ * @overload
+ * @param {UseOtpCredentialCallback} callback The callback function to be invoked
+ * @returns {UseOtpCredentialReturn}
+ *
+ * @example
+ * useOtpCredential((credential) => console.log(credential));
+ *
+ * @overload
+ * @param {UseOtpCredentialCallback} params.onSuccess The callback function to be invoked on success
+ * @param {UseOtpCredentialCallback} params.onError The callback function to be invoked on error
+ * @returns {UseOtpCredentialReturn}
+ *
+ * @example
+ * useOtpCredential({ onSuccess: (credential) => console.log(credential), onError: (error) => console.log(error) });
+ */
+export declare const useOtpCredential: UseOtpCredential;

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

@@ -0,0 +1,12 @@
+/**
+ * @name usePageLeave
+ * @description - Hook what calls given function when mouse leaves the page
+ * @category Sensors
+ *
+ * @param {() => void} [callback] The callback function what calls then mouse leaves the page
+ * @returns {boolean} A boolean which determines if the mouse left the page
+ *
+ * @example
+ * const isLeft = usePageLeave(() => console.log('on leave'))
+ */
+export declare const usePageLeave: (callback?: () => void) => boolean;

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

@@ -0,0 +1,97 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+export interface Point {
+    x: number;
+    y: number;
+}
+export declare class Pointer implements Point {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    update(point: Point): void;
+    getDifferenceTo(point: Point): Pointer;
+    getDistanceTo(point: Point): number;
+    getAngleTo(point: Point): number;
+    equalsTo(point: Point): boolean;
+    moveByAngle(angle: number, distance: number): this;
+}
+export declare class Paint {
+    pointer: Pointer;
+    brush: Pointer;
+    radius: number;
+    smooth: boolean;
+    points: Point[];
+    lines: {
+        points: Point[];
+        color: string;
+        radius: number;
+        opacity: number;
+    }[];
+    constructor({ x, y, radius, smooth }: {
+        x: number;
+        y: number;
+        radius: number;
+        smooth: boolean;
+    });
+    getBrushCoordinates(): {
+        x: number;
+        y: number;
+    };
+    getPointerCoordinates(): {
+        x: number;
+        y: number;
+    };
+    update(point: Point): boolean;
+}
+export interface UsePaintOptions {
+    /** Brush color */
+    color?: string;
+    /** Initial lines */
+    initialLines?: Paint['lines'];
+    /** Brush opacity */
+    opacity?: number;
+    /** Brush radius */
+    radius?: number;
+    /** Smooth brush movement */
+    smooth?: boolean;
+    /** Callback when the mouse is down */
+    onMouseDown?: (event: MouseEvent, paint: Paint) => void;
+    /** Callback when the mouse is moved */
+    onMouseMove?: (event: MouseEvent, paint: Paint) => void;
+    /** Callback when the mouse is up */
+    onMouseUp?: (event: MouseEvent, paint: Paint) => void;
+}
+export interface UsePaintReturn {
+    drawing: boolean;
+    lines: Paint['lines'];
+    clear: () => void;
+    draw: (points: Point[], color: string, opacity: number, radius: number) => void;
+    undo: () => void;
+}
+export interface UsePaint {
+    (target: HookTarget, options?: UsePaintOptions): UsePaintReturn;
+    <Target extends HTMLCanvasElement>(options?: UsePaintOptions, target?: never): UsePaintReturn & {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name usePaint
+ * @description - Hook that allows you to draw in a specific area
+ * @category Browser
+ *
+ * @overload
+ * @param {HookTarget} target The target element to be painted
+ * @param {UsePaintOptions} [options] The options to be used
+ * @returns {UsePaintReturn} An object containing the current pencil options and functions to interact with the paint
+ *
+ * @example
+ * const drawing = usePaint(canvasRef);
+ *
+ * @overload
+ * @param {UsePaintOptions} [options] The options to be used
+ * @returns {UsePaintReturn & { ref: StateRef<HTMLCanvasElement> }} An object containing the current pencil options and functions to interact with the paint
+ *
+ * @example
+ * const { ref, drawing } = usePaint();
+ */
+export declare const usePaint: UsePaint;

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

@@ -0,0 +1,54 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The use parallax value type */
+export interface UseParallaxValue {
+    /** Roll value. Scaled to `-0.5 ~ 0.5` */
+    roll: number;
+    /** Sensor source, can be `mouse` or `deviceOrientation` */
+    source: 'deviceOrientation' | 'mouse';
+    /** Tilt value. Scaled to `-0.5 ~ 0.5` */
+    tilt: number;
+}
+/** The use parallax options type */
+export interface UseParallaxOptions {
+    /** Device orientation roll adjust function */
+    deviceOrientationRollAdjust?: (value: number) => number;
+    /** Device orientation tilt adjust function */
+    deviceOrientationTiltAdjust?: (value: number) => number;
+    /** Mouse roll adjust function */
+    mouseRollAdjust?: (value: number) => number;
+    /** Mouse tilt adjust function */
+    mouseTiltAdjust?: (value: number) => number;
+}
+interface UseParallaxReturn {
+    value: UseParallaxValue;
+}
+export interface UseParallax {
+    (target: HookTarget, options?: UseParallaxOptions): UseParallaxReturn;
+    <Target extends Element>(options?: UseParallaxOptions, target?: never): UseParallaxReturn & {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name useParallax
+ * @description - Hook to help create parallax effect
+ * @category Sensors
+ *
+ * @overload
+ * @param {HookTarget} target The target element for the parallax effect
+ * @param {UseParallaxOptions} options The options for the parallax effect
+ * @returns {UseParallaxReturn} An object of parallax values
+ *
+ * @example
+ * const { value } = useParallax(ref);
+ *
+ * @overload
+ * @template Target The target element for the parallax effect
+ * @param {UseParallaxOptions} options The options for the parallax effect
+ * @returns {UseParallaxReturn & { ref: StateRef<Target> }} An object of parallax values
+ *
+ * @example
+ * const { ref, value } = useParallax();
+ */
+export declare const useParallax: UseParallax;
+export {};

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

@@ -0,0 +1,25 @@
+/** The use performance observer options type */
+export type UsePerformanceObserverOptions = PerformanceObserverInit & {
+    /** Whether to start the observer immediately */
+    immediate?: boolean;
+};
+/**
+ * @name usePerformanceObserver
+ * @description - Hook that allows you to observe performance entries
+ * @category Sensors
+ *
+ * @browserapi PerformanceObserver https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver
+ *
+ * @param {UsePerformanceObserverOptions} options The options for the performance observer
+ * @param {PerformanceObserverCallback} callback The function to handle performance entries
+ * @returns {object} An object containing the observer's support status and methods to start and stop the observer
+ *
+ * @example
+ * const { supported, entries, start, stop } = usePerformanceObserver();
+ */
+export declare const usePerformanceObserver: (options: UsePerformanceObserverOptions, callback?: PerformanceObserverCallback) => {
+    supported: boolean;
+    entries: PerformanceEntry[];
+    start: () => void;
+    stop: () => void;
+};

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

@@ -0,0 +1,35 @@
+/** The permission name */
+export type UsePermissionName = 'accelerometer' | 'accessibility-events' | 'ambient-light-sensor' | 'background-sync' | 'camera' | 'clipboard-read' | 'clipboard-write' | 'gyroscope' | 'magnetometer' | 'microphone' | 'notifications' | 'payment-handler' | 'persistent-storage' | 'push' | 'speaker' | PermissionName;
+/** The use permission options type */
+export interface UsePermissionOptions {
+    /** Whether the permission is enabled */
+    enabled: boolean;
+}
+/** The use permission return type */
+export interface UsePermissionReturn {
+    /** The permission state */
+    state: PermissionState;
+    /** The permission supported status */
+    supported: boolean;
+    /** The permission query function */
+    query: () => Promise<PermissionState>;
+}
+/**
+ *  @name usePermission
+ *  @description - Hook that gives you the state of permission
+ *  @category Browser
+ *
+ *  @browserapi navigator.permissions https://developer.mozilla.org/en-US/docs/Web/API/Navigator/permissions
+ *
+ *  @param {UsePermissionName} permissionDescriptorName - The permission name
+ *  @param {boolean} [options.enabled=true] - Whether the permission is enabled
+ *  @returns {UsePermissionReturn} An object containing the state and the supported status
+ *
+ *  @example
+ *  const { state, supported, query } = usePermission('microphone');
+ */
+export declare const usePermission: (permissionDescriptorName: UsePermissionName, options?: UsePermissionOptions) => {
+    state: PermissionState;
+    supported: boolean;
+    query: () => Promise<PermissionState>;
+};

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

@@ -0,0 +1,26 @@
+import { MouseEvent } from 'react';
+/** The use pointer lock return type */
+interface UsePointerLockReturn {
+    /** The pointer lock element */
+    element?: Element;
+    /** Whether the pointer lock is supported */
+    supported: boolean;
+    /** Lock the pointer lock */
+    lock: (event: MouseEvent) => void;
+    /** Unlock the pointer lock */
+    unlock: () => boolean;
+}
+/**
+ * @name usePointerLock
+ * @description - Hook that provides reactive pointer lock
+ * @category Sensors
+ *
+ * @browserapi pointerLockElement https://developer.mozilla.org/en-US/docs/Web/API/Document/pointerLockElement
+ *
+ * @returns {UsePointerLockReturn} An object containing the pointer lock element and functions to interact with the pointer lock
+ *
+ * @example
+ * const { supported, lock, unlock, element } = usePointerLock();
+ */
+export declare const usePointerLock: () => UsePointerLockReturn;
+export {};

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

@@ -0,0 +1,16 @@
+export type UsePostMessageReturn<Message> = (message: Message) => void;
+/**
+ * @name usePostMessage
+ * @description - Hook that allows you to receive messages from other origins
+ * @category Browser
+ *
+ * @overload
+ * @template Message The message data type
+ * @param {string | string[]} origin The origin of the message
+ * @param {(message: Message) => Message} callback callback to get received message
+ * @returns {(message: Message) => void} An object containing the current message
+ *
+ * @example
+ * const postMessage = usePostMessage();
+ */
+export declare const usePostMessage: <Message>(origin: string | "*" | string[], callback: (message: Message, event: MessageEvent<Message>) => void) => UsePostMessageReturn<Message>;

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

@@ -0,0 +1,13 @@
+/** The use preferred color scheme return type */
+export type UsePreferredColorSchemeReturn = 'dark' | 'light' | 'no-preference';
+/**
+ * @name usePreferredColorScheme
+ * @description - Hook that returns user preferred color scheme
+ * @category Browser
+ *
+ * @returns {UsePreferredColorSchemeReturn} String of preferred color scheme
+ *
+ * @example
+ * const colorScheme = usePreferredColorScheme();
+ */
+export declare const usePreferredColorScheme: () => UsePreferredColorSchemeReturn;

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

@@ -0,0 +1,13 @@
+/** The use preferred contrast return type */
+export type UsePreferredContrastReturn = 'custom' | 'less' | 'more' | 'no-preference';
+/**
+ * @name usePreferredContrast
+ * @description - Hook that returns the contrast preference
+ * @category Browser
+ *
+ * @returns {UsePreferredContrastReturn} The contrast preference
+ *
+ * @example
+ * const contrast = usePreferredContrast();
+ */
+export declare const usePreferredContrast: () => UsePreferredContrastReturn;

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

@@ -0,0 +1,9 @@
+/**
+ * @name usePreferredDark
+ * @description - Hook that returns if the user prefers dark mode
+ * @category Browser
+ *
+ * @example
+ * const isDark = usePreferredDark();
+ */
+export declare const usePreferredDark: () => boolean;

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

@@ -0,0 +1,13 @@
+/**
+ * @name usePreferredLanguages
+ * @description Hook that returns a browser preferred languages from navigator
+ * @category Browser
+ *
+ * @browserapi navigator.languages https://developer.mozilla.org/en-US/docs/Web/API/Navigator/languages
+ *
+ * @returns {readonly string[]} An array of strings representing the user's preferred languages
+ *
+ * @example
+ * const languages = usePreferredLanguages();
+ */
+export declare const usePreferredLanguages: () => readonly string[];

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

@@ -0,0 +1,13 @@
+/** The use preferred reduced motion return type */
+export type UsePreferredReducedMotionReturn = 'no-preference' | 'reduce';
+/**
+ * @name usePreferredReducedMotion
+ * @description - Hook that returns the reduced motion preference
+ * @category Browser
+ *
+ * @returns {UsePreferredReducedMotionReturn} The reduced motion preference
+ *
+ * @example
+ * const reduced = usePreferredReducedMotion();
+ */
+export declare const usePreferredReducedMotion: () => UsePreferredReducedMotionReturn;

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

@@ -0,0 +1,17 @@
+export interface UsePreviousOptions<Value> {
+    equality: (a: Value, b: Value) => boolean;
+}
+/**
+ * @name usePrevious
+ * @description - Hook that returns the previous value
+ * @category Utilities
+ *
+ * @template Value The type of the value
+ * @param {Value} value The value to get the previous value
+ * @param {(a: Value, b: Value) => boolean} [options.equality] The custom equality function to determine if the value has changed
+ * @returns {Value} The previous value
+ *
+ * @example
+ * const prevValue = usePrevious(value);
+ */
+export declare const usePrevious: <Value>(value: Value, options?: UsePreviousOptions<Value>) => Value | undefined;

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

@@ -0,0 +1,50 @@
+import { DependencyList } from 'react';
+export interface UseQueryOptions<QueryData, Data> {
+    enabled?: boolean;
+    initialData?: (() => Data) | Data;
+    keys?: DependencyList;
+    placeholderData?: (() => Data) | Data;
+    refetchInterval?: number;
+    retry?: boolean | number;
+    retryDelay?: ((retry: number, error: Error) => number) | number;
+    onError?: (error: Error) => void;
+    onSuccess?: (data: Data) => void;
+    select?: (data: QueryData) => Data;
+}
+interface UseQueryCallbackParams {
+    keys: DependencyList;
+    signal: AbortSignal;
+}
+export interface UseQueryReturn<Data> {
+    abort: AbortController['abort'];
+    data?: Data;
+    error?: Error;
+    isError: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isRefetching: boolean;
+    isSuccess: boolean;
+    refetch: () => void;
+}
+/**
+ * @name useQuery
+ * @description - Hook that defines the logic when query data
+ * @category Utilities
+ *
+ * @template Data The type of the data
+ * @param {() => Promise<Data>} callback The callback function to be invoked
+ * @param {DependencyList} [options.keys] The dependencies for the hook
+ * @param {(data: Data) => void} [options.onSuccess] The callback function to be invoked on success
+ * @param {(error: Error) => void} [options.onError] The callback function to be invoked on error
+ * @param {UseQueryOptionsSelect<Data>} [options.select] The select function to be invoked
+ * @param {Data | (() => Data)} [options.initialData] The initial data for the hook
+ * @param {Data | (() => Data)} [options.placeholderData] The placeholder data for the hook
+ * @param {number} [options.refetchInterval] The refetch interval
+ * @param {boolean | number} [options.retry] The retry count of requests
+ * @returns {UseQueryReturn<Data>} An object with the state of the query
+ *
+ * @example
+ * const { data, isFetching, isLoading, isError, isSuccess, error, refetch, isRefetching, abort, aborted } = useQuery(() => fetch('url'));
+ */
+export declare const useQuery: <QueryData, Data = QueryData>(callback: (params: UseQueryCallbackParams) => Promise<QueryData>, options?: UseQueryOptions<QueryData, Data>) => UseQueryReturn<Data>;
+export {};

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

@@ -0,0 +1,30 @@
+/** The use queue return type */
+export interface UseQueueReturn<Value> {
+    /** Get the first element of the queue */
+    first: Value;
+    /** Get the last element of the queue */
+    last: Value;
+    /** The current queue */
+    queue: Value[];
+    /** Get the size of the queue */
+    size: number;
+    /** Add an element to the queue */
+    add: (element: Value) => void;
+    /** Clear the queue */
+    clear: () => void;
+    /** Remove an element from the queue */
+    remove: () => Value;
+}
+/**
+ * @name useQueue
+ * @description - Hook that manages a queue
+ * @category Utilities
+ *
+ * @template Value The type of the value
+ * @param {Value[]} [initialValue=[]] The initial value of the queue
+ * @returns {UseQueueReturn} An object containing the current queue and functions to interact with the queue
+ *
+ * @example
+ * const { queue, add, remove, clear, first, last, size } = useQueue([1, 2, 3]);
+ */
+export declare const useQueue: <Value>(initialValue?: Value[]) => UseQueueReturn<Value>;