sse-hooks 1.3.0 → 2.0.0

package/dist/index.d.mts

@@ -1,2429 +0,0 @@
-import React$1, { Dispatch, SetStateAction, RefObject, useEffect } from 'react';
-
-declare enum EffectFlags {
-    ACTIVE = 1,
-    RUNNING = 2,
-    TRACKING = 4,
-    NOTIFIED = 8,
-    DIRTY = 16,
-    ALLOW_RECURSE = 32,
-    PAUSED = 64
-}
-declare enum TrackOpTypes {
-    GET = "get",
-    HAS = "has",
-    ITERATE = "iterate"
-}
-declare enum TriggerOpTypes {
-    SET = "set",
-    ADD = "add",
-    DELETE = "delete",
-    CLEAR = "clear"
-}
-declare const ReactiveFlags: {
-    readonly IS_REF: "__v_isRef";
-    readonly IS_READONLY: "__v_isReadonly";
-    readonly SKIP: "__v_skip";
-};
-
-declare let globalVersion: number;
-declare class Link {
-    sub: Subscriber;
-    dep: Dep;
-    version: number;
-    nextDep?: Link;
-    prevDep?: Link;
-    nextSub?: Link;
-    prevSub?: Link;
-    prevActiveLink?: Link;
-    constructor(sub: Subscriber, dep: Dep);
-}
-declare class Dep {
-    computed?: ComputedRefImpl | undefined;
-    version: number;
-    activeLink?: Link;
-    subs?: Link;
-    subsHead?: Link;
-    map?: Map<any, Dep>;
-    key?: unknown;
-    sc: number;
-    constructor(computed?: ComputedRefImpl | undefined);
-    track(debugInfo?: DebuggerEventExtraInfo): Link | undefined;
-    trigger(debugInfo?: DebuggerEventExtraInfo): void;
-    notify(debugInfo?: DebuggerEventExtraInfo): void;
-}
-type KeyToDepMap = Map<any, Dep>;
-declare const targetMap: WeakMap<object, KeyToDepMap>;
-declare function track(target: object, type: TrackOpTypes, key: unknown): void;
-
-interface Subscriber {
-    deps?: Link;
-    depsTail?: Link;
-    flags: EffectFlags;
-    next?: Subscriber;
-    notify(): true | void;
-    onTrack?: (event: DebuggerEvent) => void;
-    onTrigger?: (event: DebuggerEvent) => void;
-}
-type DebuggerEvent = {
-    effect: Subscriber;
-} & DebuggerEventExtraInfo;
-type DebuggerEventExtraInfo = {
-    target: object;
-    type: TrackOpTypes | TriggerOpTypes;
-    key: any;
-    newValue?: any;
-    oldValue?: any;
-    oldTarget?: Map<any, any> | Set<any>;
-};
-interface DebuggerOptions {
-    onTrack?: (event: DebuggerEvent) => void;
-    onTrigger?: (event: DebuggerEvent) => void;
-}
-declare let shouldTrack: boolean;
-declare function getActiveSub(): Subscriber | undefined;
-declare function setActiveSub(sub: Subscriber | undefined): void;
-declare function startBatch(): void;
-declare function endBatch(): void;
-declare function batch(sub: Subscriber, isComputed?: boolean): void;
-
-interface Ref<T = any> {
-    value: T;
-}
-declare class RefImpl<T> implements Ref<T> {
-    private _value;
-    dep: Dep;
-    __v_isRef: boolean;
-    constructor(value: T);
-    get value(): T;
-    set value(newVal: T);
-}
-declare function ref<T>(value: T): Ref<T>;
-
-declare const ComputedRefSymbol: unique symbol;
-type BaseComputedRef<T> = Ref<T> & {
-    [ComputedRefSymbol]: true;
-    effect: Subscriber;
-};
-type ComputedRef<T = any> = BaseComputedRef<T> & {
-    readonly value: T;
-};
-type ComputedGetter<T> = (oldValue?: T) => T;
-type ComputedSetter<T> = (newValue: T) => void;
-interface WritableComputedOptions<T> {
-    get: ComputedGetter<T>;
-    set: ComputedSetter<T>;
-}
-declare function refreshComputed(computed: ComputedRefImpl): void;
-declare class ComputedRefImpl<T = any> implements Subscriber {
-    fn: ComputedGetter<T>;
-    private readonly setter;
-    _value: any;
-    readonly dep: Dep;
-    readonly __v_isRef = true;
-    deps?: Link;
-    depsTail?: Link;
-    flags: EffectFlags;
-    globalVersion: number;
-    isSSR: boolean;
-    effect: this;
-    onTrack?: (event: DebuggerEvent) => void;
-    onTrigger?: (event: DebuggerEvent) => void;
-    constructor(fn: ComputedGetter<T>, setter: ComputedSetter<T> | undefined, isSSR: boolean);
-    notify(): true | void;
-    get value(): T;
-    set value(newValue: T);
-}
-declare function computed<T>(getterOrOptions: ComputedGetter<T> | WritableComputedOptions<T>, debugOptions?: DebuggerOptions, isSSR?: boolean): any;
-
-declare function useReactive<T>(refObj: Ref<T>): T;
-declare function useComputed<T>(getter: () => T, deps?: any[]): T;
-
-declare const extend: {
-    <T extends {}, U>(target: T, source: U): T & U;
-    <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
-    <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
-    (target: object, ...sources: any[]): any;
-};
-declare const isArray: (arg: any) => arg is any[];
-declare const isMap: (val: unknown) => val is Map<any, any>;
-declare const isFunction: (val: unknown) => val is Function;
-declare const isSymbol: (val: unknown) => val is symbol;
-declare const isObject: (val: unknown) => val is Record<any, any>;
-declare const isIntegerKey: (key: any) => boolean;
-declare const __DEV__: boolean;
-
-/** Supported audio MIME types for recording. */
-type AudioMimeType = "audio/webm" | "audio/webm;codecs=opus" | "audio/webm;codecs=vorbis" | "audio/ogg" | "audio/ogg;codecs=opus" | "audio/ogg;codecs=vorbis" | "application/ogg" | "audio/mp4" | "audio/mp4;codecs=mp4a.40.2" | "audio/aac" | "audio/x-m4a" | "audio/mpeg" | "audio/mp3" | "audio/wav" | "audio/x-wav" | "audio/wave" | "audio/flac" | "audio/3gpp" | "audio/3gpp2";
-/** Options for configuring the useAudioRecorder hook. */
-interface UseAudioRecorderOptions {
-    /**
-     * Audio bitrate in bits per second.
-     * @default 128000
-     */
-    audioBitsPerSecond?: number;
-    /**
-     * MIME type for the recorded audio.
-     * @default "audio/webm"
-     */
-    mimeType?: AudioMimeType;
-    /**
-     * Timeslice (ms) for MediaRecorder data chunks.
-     */
-    timeslice?: number;
-    /**
-     * If set, enables real-time audio analysis during recording.
-     */
-    enableAnalysis?: boolean;
-    /**
-     * FFT size for audio analysis.
-     * @default 2048
-     */
-    fftSize?: number;
-}
-/** Audio analysis data returned when `enableAnalysis` is true. */
-interface AudioAnalysisData {
-    /** Frequency domain data (FFT). */
-    frequencyData: Uint8Array;
-    /** Time domain waveform data. */
-    timeData: Uint8Array;
-    /** Calculated RMS volume level. */
-    volume: number;
-}
-/** The useAudioRecorder return type. */
-interface UseAudioRecorderReturn {
-    /** Whether audio recording is supported in the current browser. */
-    isSupported: boolean;
-    /** Whether recording is currently active. */
-    isRecording: boolean;
-    /** Whether recording is currently paused. */
-    isPaused: boolean;
-    /** Active media stream. */
-    stream: MediaStream | null;
-    /** MediaRecorder instance. */
-    mediaRecorder: MediaRecorder | null;
-    /** Final recorded audio blob. */
-    audioBlob: Blob | null;
-    /** Object URL for the recorded audio. */
-    audioUrl: string | null;
-    /** Duration of the recording in seconds. */
-    duration: number;
-    /** Error message if recording fails. */
-    error: string | null;
-    /** Live audio analysis data. */
-    analysisData: AudioAnalysisData | null;
-    /** Starts audio recording. */
-    startRecording: () => Promise<void>;
-    /** Stops audio recording. */
-    stopRecording: () => void;
-    /** Pauses the recording. */
-    pauseRecording: () => void;
-    /** Resumes a paused recording. */
-    resumeRecording: () => void;
-    /** Clears the current recording state. */
-    clearRecording: () => void;
-    /** Downloads the recording as a file. */
-    downloadRecording: (filename?: string) => void;
-}
-
-/**
- * A comprehensive hook for audio recording with real-time analysis using getUserMedia, MediaRecorder, and Web Audio APIs
- *
- * @category sensors
- * @param {UseAudioRecorderOptions} [options] - Configuration options for audio recording.
- * @returns {UseAudioRecorderReturn} Object containing recording state, audio data, and control methods.
- * @throws Will set an error if audio recording is not supported or permission is denied.
- * @public
- * @example
- * ```tsx
- * const {
- *   isRecording,
- *   startRecording,
- *   stopRecording,
- *   audioUrl,
- * } = useAudioRecorder({ enableAnalysis: true });
- * ```
- */
-declare const useAudioRecorder: (options?: UseAudioRecorderOptions) => UseAudioRecorderReturn;
-
-/**
- * Represents the state of the battery.
- */
-interface BatteryState {
-    /**
-     * A boolean value indicating whether the battery is currently being charged.
-     */
-    charging: boolean;
-    /**
-     * A number representing the remaining time in seconds until the battery is fully charged,
-     * or 0 if the battery is already fully charged.
-     */
-    chargingTime: number;
-    /**
-     * A number representing the remaining time in seconds until the battery is completely discharged
-     * and the system will suspend.
-     */
-    dischargingTime: number;
-    /**
-     * A number representing the system's battery charge level scaled to a value between 0.0 and 1.0.
-     */
-    level: number;
-}
-/**
- * Return type for the `useBattery` hook.
- * It is a discriminated union based on the `isSupported` and `fetched` states.
- */
-type UseBatteryState = {
-    isSupported: false;
-} | {
-    isSupported: true;
-    fetched: false;
-} | (BatteryState & {
-    isSupported: true;
-    fetched: true;
-});
-/**
- * Custom hook that tracks the state of the device's battery using the [Battery Status API](https://developer.mozilla.org/en-US/docs/Web/API/Battery_Status_API).
- *
- * It returns the battery level, charging status, charging time, and discharging time.
- * If the API is not supported, `isSupported` will be false.
- *
- * @returns {UseBatteryState} The current state of the battery, including support and fetch status.
- * @public
- * @example
- * ```tsx
- * const battery = useBattery();
- *
- * if (!battery.isSupported) {
- * return <p>Battery API is not supported on this device.</p>;
- * }
- *
- * if (!battery.fetched) {
- * return <p>Fetching battery status...</p>;
- * }
- *
- * return (
- * <div>
- * <p>Battery Level: {(battery.level * 100).toFixed(0)}%</p>
- * <p>Charging: {battery.charging ? 'Yes' : 'No'}</p>
- * </div>
- * );
- * ```
- */
-declare function useBattery(): UseBatteryState;
-/**
- * Custom hook that tracks the state of the device's battery using the [Battery Status API](https://developer.mozilla.org/en-US/docs/Web/API/Battery_Status_API).
- *
- * It returns the battery level, charging status, charging time, and discharging time.
- * If the API is not supported, `isSupported` will be false.
- *
- * @returns {UseBatteryState} The current state of the battery, including support and fetch status.
- * @public
- * @example
- * ```tsx
- * const battery = useBattery();
- *
- * if (!battery.isSupported) {
- * return <p>Battery API is not supported on this device.</p>;
- * }
- *
- * if (!battery.fetched) {
- * return <p>Fetching battery status...</p>;
- * }
- *
- * return (
- * <div>
- * <p>Battery Level: {(battery.level * 100).toFixed(0)}%</p>
- * <p>Charging: {battery.charging ? 'Yes' : 'No'}</p>
- * </div>
- * );
- * ```
- */
-declare const useBatteryHook: typeof useBattery;
-
-/** The useBoolean return type. */
-type UseBooleanReturn = {
-    /** The current boolean state value. */
-    value: boolean;
-    /** Function to set the boolean state directly. */
-    setValue: React$1.Dispatch<React$1.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.
- *
- * @category state
- * @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
- * @example
- * ```tsx
- * const { value, setTrue, setFalse, toggle } = useBoolean(true);
- * ```
- */
-declare function useBoolean(defaultValue?: boolean): UseBooleanReturn;
-
-/**
- * Breakpoints from Tailwind V2
- *
- * @see https://tailwindcss.com/docs/breakpoints
- */
-declare const breakpointsTailwind: {
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-    "2xl": number;
-};
-/**
- * Breakpoints from Bootstrap V5
- *
- * @see https://getbootstrap.com/docs/5.0/layout/breakpoints
- */
-declare const breakpointsBootstrapV5: {
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-    xxl: number;
-};
-/**
- * Breakpoints from Vuetify V2
- *
- * @see https://vuetifyjs.com/en/features/breakpoints
- */
-declare const breakpointsVuetify: {
-    xs: number;
-    sm: number;
-    md: number;
-    lg: number;
-};
-/**
- * Breakpoints from Ant Design
- *
- * @see https://ant.design/components/layout/#breakpoint-width
- */
-declare const breakpointsAntDesign: {
-    xs: number;
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-    xxl: number;
-};
-/**
- * Sematic Breakpoints
- */
-declare const breakpointsSematic: {
-    mobileS: number;
-    mobileM: number;
-    mobileL: number;
-    tablet: number;
-    laptop: number;
-    laptopL: number;
-    desktop4K: number;
-};
-
-declare function useBreakpoint<BreakPoints extends Record<string, number>, BreakPointsKey extends keyof BreakPoints = keyof BreakPoints>(breakpoints: BreakPoints): {
-    /**
-     * Hook that returns a boolean if screen width is greater than given breakpoint.
-     *
-     * @param k {string} breakpoint
-     * @returns boolean
-     *
-     * @see https://react-hooks-library.vercel.app/core/BreakPointHooks
-     **/
-    useGreater: (k: BreakPointsKey) => boolean;
-    /**
-     * Hook that returns a boolean if screen width is smaller than given breakpoint.
-     *
-     * @param k {string} breakpoint
-     * @param k {string} breakpoint
-     *
-     * @returns boolean
-     *
-     * @see https://react-hooks-library.vercel.app/core/BreakPointHooks
-     **/
-    useSmaller: (k: BreakPointsKey) => boolean;
-    /**
-     * Hook that returns a boolean if screen width is between two given breakpoint.
-     *
-     * @param a {string} breakpoint
-     * @param b {string} breakpoint
-     *
-     * @returns boolean
-     *
-     * @see https://react-hooks-library.vercel.app/core/BreakPointHooks
-     **/
-    useBetween: (a: BreakPointsKey, b: BreakPointsKey) => boolean;
-    /**
-     * Utility function that returns a boolean if screen width is greater than given breakpoint.
-     *
-     * @param k {string} breakpoint
-     *
-     * @see https://react-hooks-library.vercel.app/core/BreakPointHooks
-     **/
-    isGreater(k: BreakPointsKey): boolean;
-    /**
-     * Utility function that returns a boolean if screen width is smaller than given breakpoint.
-     *
-     * @param k {string} breakpoint
-     *
-     * @see https://react-hooks-library.vercel.app/core/BreakPointHooks
-     **/
-    isSmaller(k: BreakPointsKey): boolean;
-    /**
-     * Utility function that returns a boolean if screen width is between two given breakpoint.
-     *
-     * @param k {string} breakpoint
-     *
-     * @see https://react-hooks-library.vercel.app/core/BreakPointHooks
-     **/
-    isInBetween(a: BreakPointsKey, b: BreakPointsKey): boolean;
-};
-
-/**
- * Custom hook that handles click events anywhere on the document.
- *
- * @category dom
- * @param {Function} handler - The function to be called when a click event is detected anywhere on the document.
- * @public
- * @see [Documentation](/docs/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;
-
-/**
- * Supported touch events for the click-away listener.
- */
-type ClickAwayTouchEventHandler = "onTouchStart" | "onTouchEnd";
-/**
- * Supported mouse events for the click-away listener.
- */
-type ClickAwayMouseEventHandler = "onClick" | "onMouseDown" | "onMouseUp" | "onPointerDown" | "onPointerUp";
-/**
- * Options for the `useClickAway` hook.
- */
-interface UseClickAwayOptions {
-    /**
-     * If `true`, the React tree is ignored and only the DOM tree is considered.
-     * This prop changes how portaled elements are handled.
-     * @default false
-     */
-    disableReactTree?: boolean;
-    /**
-     * The mouse event to listen to. You can disable the listener by providing `false`.
-     * @default 'onClick'
-     */
-    mouseEvent?: ClickAwayMouseEventHandler | false;
-    /**
-     * The touch event to listen to. You can disable the listener by providing `false`.
-     * @default 'onTouchEnd'
-     */
-    touchEvent?: ClickAwayTouchEventHandler | false;
-    /**
-     * An external ref to merge with the hook's internal ref.
-     * Useful if you need to access the DOM element outside of this hook.
-     */
-    ref?: React$1.Ref<Element>;
-}
-/**
- * Custom hook that triggers a callback when a user clicks outside the referenced element.
- * It handles portal elements, scrollbar clicks, and touch interactions intelligently.
- *
- * @category dom
- * @param onClickAway - The callback function to be called when a click outside is detected.
- * @param options - Configuration options for the hook.
- * @returns {object} An object containing the `ref` to attach to the target element and `listenerProps` to spread.
- * @public
- * @example
- * ```tsx
- * const handleClickAway = () => {
- * console.log('Clicked outside!');
- * setOpen(false);
- * };
- *
- * const { ref, listenerProps } = useClickAway(handleClickAway);
- *
- * return (
- * <div ref={ref} {...listenerProps}>
- * I will detect clicks outside of me.
- * </div>
- * );
- * ```
- */
-declare function useClickAway(onClickAway: (event: MouseEvent | TouchEvent) => void, options?: UseClickAwayOptions): {
-    ref: React$1.Ref<Element>;
-    listenerProps: Record<string, any>;
-};
-
-interface UseScreenShareOptions {
-    /**
-     * Boolean or specific constraints for the video track.
-     * @default true
-     */
-    video?: boolean | MediaTrackConstraints;
-    /**
-     * Boolean or specific constraints for the audio track.
-     * @default true
-     */
-    audio?: boolean | MediaTrackConstraints;
-}
-interface UseScreenShareReturn {
-    /**
-     * The current MediaStream object, or null if no stream is active.
-     */
-    stream: MediaStream | null;
-    /**
-     * An error message string if the media capture failed, or null otherwise.
-     */
-    error: string | null;
-    /**
-     * A boolean indicating if the media stream is currently loading (requesting permission).
-     */
-    isLoading: boolean;
-    /**
-     * A boolean indicating if the `getUserMedia` API is supported in the current environment.
-     */
-    isSupported: boolean;
-    /**
-     * Function to start capturing media. Accepts optional constraints to override defaults.
-     */
-    startCapture: (constraints?: UseScreenShareOptions) => Promise<void>;
-    /**
-     * Function to stop the current media capture and release tracks.
-     */
-    stopCapture: () => void;
-}
-
-/**
- * Custom hook that captures the user's screen or specific application window.
- * It handles permission errors, stream management, native stop events, and cleanup.
- *
- * @category sensors
- * @param initialOptions - The initial options for screen sharing (video/audio).
- * @returns {UseScreenShareReturn} An object containing the stream, error state, and control functions.
- * @public
- * @example
- * ```tsx
- * const { stream, error, startCapture, stopCapture } = useScreenShare();
- *
- * return (
- * <div>
- * {error && <p>Error: {error}</p>}
- * <video
- * autoPlay
- * muted
- * playsInline
- * ref={(node) => {
- * if (node && stream) node.srcObject = stream;
- * }}
- * />
- * <button onClick={() => startCapture()}>Share Screen</button>
- * <button onClick={stopCapture}>Stop Sharing</button>
- * </div>
- * );
- * ```
- */
-declare function useScreenShare(initialOptions?: UseScreenShareOptions): {
-    stream: MediaStream | null;
-    error: string | null;
-    isLoading: boolean;
-    isSupported: boolean;
-    startCapture: (options?: UseScreenShareOptions) => Promise<void>;
-    stopCapture: () => void;
-};
-
-/**
- * Constraints for the `useUserMedia` hook.
- * Defines the video and audio settings for the media stream.
- */
-interface UseUserMediaConstraints {
-    /**
-     * Boolean or specific constraints for the video track.
-     * @default true
-     */
-    video?: boolean | MediaTrackConstraints;
-    /**
-     * Boolean or specific constraints for the audio track.
-     * @default true
-     */
-    audio?: boolean | MediaTrackConstraints;
-}
-/**
- * Return type for the `useUserMedia` hook.
- */
-interface UseUserMediaReturn {
-    /**
-     * The current MediaStream object, or null if no stream is active.
-     */
-    stream: MediaStream | null;
-    /**
-     * An error message string if the media capture failed, or null otherwise.
-     */
-    error: string | null;
-    /**
-     * A boolean indicating if the media stream is currently loading (requesting permission).
-     */
-    isLoading: boolean;
-    /**
-     * A boolean indicating if the `getUserMedia` API is supported in the current environment.
-     */
-    isSupported: boolean;
-    /**
-     * Function to start capturing media. Accepts optional constraints to override defaults.
-     */
-    startCapture: (constraints?: UseUserMediaConstraints) => Promise<void>;
-    /**
-     * Function to stop the current media capture and release tracks.
-     */
-    stopCapture: () => void;
-}
-
-/**
- * Custom hook that captures audio and video from the user's device.
- * It handles permission errors, stream management, and cleanup automatically.
- *
- * @category sensors
- * @param initialConstraints - The initial constraints for audio and video.
- * @returns {UseUserMediaReturn} An object containing the stream, error state, and control functions.
- * @public
- * @example
- * ```tsx
- * const { stream, error, startCapture, stopCapture } = useUserMedia();
- *
- * return (
- * <div>
- * {error && <p>Error: {error}</p>}
- * <video
- * autoPlay
- * muted
- * playsInline
- * ref={(node) => {
- * if (node && stream) node.srcObject = stream;
- * }}
- * />
- * <button onClick={() => startCapture()}>Start Camera</button>
- * <button onClick={stopCapture}>Stop Camera</button>
- * </div>
- * );
- * ```
- */
-declare const useUserMedia: (initialConstraints?: UseUserMediaConstraints) => UseUserMediaReturn;
-
-type MediaQuality = "low" | "medium" | "high";
-type QualityPresetTypes = Record<MediaQuality, MediaTrackConstraints>;
-interface UseMediaQualityReturn {
-    /** The current quality preset being used. */
-    quality: MediaQuality;
-    /** Whether the constraints are currently being applied to the track. */
-    isChanging: boolean;
-    /** Function to change the video quality. */
-    setQuality: (level: MediaQuality) => Promise<void>;
-}
-
-/**
- * Custom hook to manage video stream quality by applying constraints (resolution and frame rate)
- * to a MediaStream track.
- * * @category utilities
- * @param {MediaStream | null} stream - The MediaStream containing the video track to adjust.
- * @returns {UseMediaQualityReturn} The current quality state and a setter function.
- * @public
- * @see [Documentation](/docs/use-media-quality)
- * @example
- * ```tsx
- * const { quality, setQuality, isChanging } = useMediaQuality(userVideoStream);
- * * const handleHDClick = () => {
- * setQuality('high'); // Switches to 1280x720
- * };
- * ```
- */
-declare const useMediaQuality: (stream: MediaStream | null) => UseMediaQualityReturn;
-
-/**
- * Configuration options for the conference system hook.
- */
-interface UseConferenceSystemOptions {
-    /**
-     * Whether to enable automatic network-based quality scaling on mount.
-     * @default true
-     */
-    defaultAutoQuality?: boolean;
-}
-/**
- * The state and controller object returned by the useConferenceSystem hook.
- */
-interface UseConferenceSystemReturns {
-    /** Camera management and state */
-    camera: {
-        /** The active MediaStream for the camera, or null if inactive. */
-        stream: MediaStream | null;
-        /** Starts the camera capture with optional constraints. */
-        start: (constraints?: UseUserMediaConstraints) => Promise<void>;
-        /** Stops the camera capture and clears the stream. */
-        stop: () => void;
-        /** Whether the camera stream is currently active. */
-        isActive: boolean;
-        /** Error message if camera access or capture fails. */
-        error: string | null;
-        /** Indicates if the camera is currently requesting permissions or initializing. */
-        isLoading: boolean;
-    };
-    /** Screen sharing management and state */
-    screen: {
-        /** The active MediaStream for screen sharing, or null if inactive. */
-        stream: MediaStream | null;
-        /** Starts the screen share capture process. */
-        start: (options?: UseScreenShareOptions) => Promise<void>;
-        /** Stops the screen share and clears the stream. */
-        stop: () => void;
-        /** Whether the screen share is currently active. */
-        isActive: boolean;
-        /** Error message if screen share access fails or is denied. */
-        error: string | null;
-    };
-    /** Media quality management */
-    quality: {
-        /** The currently applied quality level ('low', 'medium', 'high'). */
-        current: MediaQuality;
-        /** Whether a quality transition is currently in progress. */
-        isChanging: boolean;
-        /** Manually sets the media quality level (overrides auto-quality). */
-        set: (level: MediaQuality) => Promise<void>;
-        /** Whether automatic quality adjustment is currently enabled. */
-        isAuto: boolean;
-        /** Toggles the automatic quality scaling logic on or off. */
-        toggleAuto: () => void;
-    };
-    /** Network status and telemetry */
-    network: {
-        /** Boolean indicating if the browser has an active internet connection. */
-        isOnline: boolean;
-        /** Estimated downlink speed in Mbps. */
-        speed: number;
-        /** The network connection type (e.g., '4g', 'wifi', 'unknown'). */
-        type: string;
-    };
-}
-
-/**
- * A comprehensive hook for managing video conferencing state, including camera access, screen sharing, network monitoring, and automatic media quality adjustment.
- *
- * @category sensors
- * @param {UseConferenceSystemOptions} [options={}] - Configuration options for the conference system.
- * @param {boolean} [options.defaultAutoQuality=true] - Whether to enable network-based quality scaling by default.
- * @returns {UseConferenceSystemReturns} An object containing camera, screen, quality, and network state controllers.
- * @public
- * @see [Documentation](/docs/use-conference-system)
- * @example
- * ```tsx
- * const { camera, screen, quality, network } = useConferenceSystem({
- * defaultAutoQuality: true
- * });
- * * return (
- * <div>
- * <video ref={v => v.srcObject = camera.stream} autoPlay />
- * <button onClick={camera.start}>Start Camera</button>
- * <p>Current Quality: {quality.current} (Auto: {quality.isAuto ? 'On' : 'Off'})</p>
- * <p>Network Speed: {network.speed} Mbps</p>
- * </div>
- * );
- * ```
- */
-declare const useConferenceSystem: (options?: UseConferenceSystemOptions) => UseConferenceSystemReturns;
-
-declare global {
-    interface WindowEventMap {
-        "cookie-change": CustomEvent<{
-            key: string;
-        }>;
-        visibilitychange: Event;
-    }
-}
-/**
- * Options for customizing the behavior of the useCookie hook.
- * @template T - The type of the state to be stored in the cookie.
- */
-type UseCookieOptions<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 cookie.
-     * @default true
-     */
-    initializeWithValue?: boolean;
-    /**
-     * A prefix to be prepended to the key (e.g., "myApp_").
-     * Useful for namespacing or complying with cookie prefixes like `__Secure-` or `__Host-`.
-     */
-    prefix?: string;
-    /**
-     * The path within the site for which the cookie is valid.
-     * @default "/"
-     */
-    path?: string;
-    /** The domain for which the cookie is valid. */
-    domain?: string;
-    /** The expiration date of the cookie. */
-    expires?: Date;
-    /** The maximum age of the cookie in seconds. */
-    maxAge?: number;
-    /** If `true`, the cookie is only transmitted over secure protocols (HTTPS). */
-    secure?: boolean;
-    /**
-     * Controls whether the cookie is sent with cross-site requests.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite
-     */
-    sameSite?: "lax" | "strict" | "none";
-    /** The default value to return if the cookie is not found. */
-    defaultValue?: T;
-};
-/**
- * Custom hook that manages state synchronized with a browser [`cookie`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies). It handles serialization, prefixes, updates across tabs, and custom event synchronization.
- *
- * @category storage
- * @template T - The type of the state to be stored in the cookie.
- * @param {string} key - The base name of the cookie.
- * @param {T | (() => T)} initialValue - The initial value of the state.
- * @param {UseCookieOptions<T>} [options] - Options for customization.
- * @returns {[T, Dispatch<SetStateAction<T>>, () => void]} A tuple containing the stored value, a setter, and a remover.
- * @public
- * @see [Documentation](/docs/use-cookie)
- * @example
- * ```tsx
- * // Creates a cookie named "__Secure-token"
- * const [token, setToken] = useCookie('token', '', {
- * prefix: '__Secure-',
- * secure: true,
- * });
- * ```
- */
-declare function useCookie<T>(key: string, initialValue: T | (() => T), options?: UseCookieOptions<T>): [T, Dispatch<SetStateAction<T>>, () => void];
-
-/**
- * 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).
- *
- * @category utilities
- * @returns {[CopiedValue, CopyFn]} An tuple containing the copied text and a function to copy text to the clipboard.
- * @public
- * @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];
-
-/** 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.
- *
- * @category effect
- * @param {CountdownOptions} countdownOptions - The countdown's options.
- * @returns {[number, CountdownControllers]} An array containing the countdown's count and its controllers.
- * @public
- * @see [Documentation](/docs/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];
-
-/** 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: React$1.Dispatch<React$1.SetStateAction<number>>;
-};
-/**
- * Custom hook that manages a counter with increment, decrement, reset, and setCount functionalities.
- *
- * @category state
- * @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](/docs/use-counter)
- * @example
- * ```tsx
- * const { count, increment, decrement, reset, setCount } = useCounter(5);
- * ```
- */
-declare function useCounter(initialValue?: number): UseCounterReturn;
-
-/** 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 'sse-hooks-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.
- *
- * @category dom
- * @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](/docs/use-dark-mode)
- * @example
- * ```tsx
- * const { isDarkMode, toggle, enable, disable, set } = useDarkMode({ defaultValue: true });
- * ```
- */
-declare function useDarkMode(options?: DarkModeOptions): DarkModeReturn;
-
-/** Configuration options for controlling the behavior of the debounced function. */
-type DebounceOptions = {
-    /**
-     * 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;
-};
-/** 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.
- *
- * @category effect
- * @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](/docs/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>;
-
-/**
- * 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.
- *
- * @category effect
- * @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](/docs/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>];
-
-/** 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.
- *
- * @category dom
- * @param {string} title - The title to set.
- * @param {?UseDocumentTitleOptions} [options] - The options.
- * @public
- * @see [Documentation](/docs/use-document-title)
- * @example
- * ```tsx
- * useDocumentTitle('My new title');
- * ```
- */
-declare function useDocumentTitle(title: string, options?: UseDocumentTitleOptions): void;
-
-/**
- * Custom hook that creates a memoized event callback.
- *
- * @category utilities
- * @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](/docs/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;
-
-declare function useEventListener<K extends keyof MediaQueryListEventMap>(eventName: K, handler: (event: MediaQueryListEventMap[K]) => void, element: RefObject<MediaQueryList>, 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>, options?: boolean | AddEventListenerOptions): void;
-declare function useEventListener<K extends keyof DocumentEventMap>(eventName: K, handler: (event: DocumentEventMap[K]) => void, element: RefObject<Document>, options?: boolean | AddEventListenerOptions): void;
-
-/**
- * Options for customizing the behavior of the useFetch hook.
- * Extends the standard [`RequestInit`](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit) interface.
- */
-interface UseFetchOptions extends RequestInit {
-    /**
-     * If `true`, the fetch request will be executed immediately upon mounting or when the URL changes.
-     * @default false
-     */
-    immediate?: boolean;
-    /**
-     * Callback function invoked when the request completes successfully.
-     * @param data - The parsed response data.
-     */
-    onSuccess?: (data: any) => void;
-    /**
-     * Callback function invoked when the request fails.
-     * @param error - The error object.
-     */
-    onError?: (error: Error) => void;
-}
-/**
- * The state representation of the fetch request.
- * @template T - The type of the data.
- */
-interface UseFetchState<T> {
-    /** The data received from the response, or null if not yet received. */
-    data: T | null;
-    /** Indicates if the request is currently in progress. */
-    loading: boolean;
-    /** The error object if the request failed, or null if successful. */
-    error: Error | null;
-}
-/**
- * The return value of the useFetch hook, including state and control methods.
- * @template T - The type of the data.
- */
-interface UseFetchReturn<T> extends UseFetchState<T> {
-    /**
-     * Manually triggers the fetch request.
-     * @param {string} [url] - Optional override URL.
-     * @param {RequestInit} [options] - Optional override options.
-     * @returns {Promise<T | null>} A promise that resolves to the data or null.
-     */
-    execute: (url?: string, options?: RequestInit) => Promise<T | null>;
-    /** Aborts the current request if it is pending. */
-    abort: () => void;
-    /** Resets the state to its initial values (data: null, loading: false, error: null). */
-    reset: () => void;
-}
-/**
- * Custom hook that provides a wrapper around the native [`fetch API`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) to handle HTTP requests with state management, abort capability, and TypeScript support.
- *
- * @category network
- * @template T - The type of the data expected from the response.
- * @param {string} [url] - The URL to fetch.
- * @param {UseFetchOptions} [options] - Options for customizing the request and hook behavior (optional).
- * @returns {UseFetchReturn<T>} An object containing the fetched data, loading status, error, and methods to control the request.
- * @public
- * @example
- * ```tsx
- * interface User {
- * id: number;
- * name: string;
- * }
- *
- * const { data, loading, error, execute } = useFetch<User>('https://api.example.com/user/1', {
- * immediate: true,
- * onSuccess: (data) => console.log('User loaded:', data),
- * });
- * ```
- */
-declare function useFetch<T = any>(url?: string, options?: UseFetchOptions): UseFetchReturn<T>;
-declare function useGet<T = any>(url?: string, options?: UseFetchOptions): UseFetchReturn<T>;
-declare function usePost<T = any>(url?: string, options?: UseFetchOptions): UseFetchReturn<T>;
-declare function usePut<T = any>(url?: string, options?: UseFetchOptions): UseFetchReturn<T>;
-declare function useDelete<T = any>(url?: string, options?: UseFetchOptions): UseFetchReturn<T>;
-
-/**
- * Merges refs into a single memoized callback ref or `null`.
- *
- * @category dom
- * @template Instance - The type of the value being referenced (usually a DOM element).
- * @param {Array<React.Ref<Instance> | undefined>} refs The ref array.
- * @returns {React.RefCallback<Instance> | null} The new ref callback.
- * @public
- * @example
- * ```tsx
- * const rootRef = React.useRef<Instance>(null);
- * const refFork = useForkRef(rootRef, props.ref);
- *
- * return (
- *   <Root {...props} ref={refFork} />
- * );
- * ```
- *
- */
-declare function useForkRef<Instance>(...refs: Array<React$1.Ref<Instance> | undefined>): React$1.RefCallback<Instance> | null;
-
-/**
- * Custom hook that tracks whether a DOM element is being hovered over.
- * @template T - The type of the DOM element. Defaults to `HTMLElement`.
- * @category sensors
- * @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](/docs/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>): boolean;
-
-/**
- * Options for configuring the IndexedDB connection and behavior.
- */
-interface UseIndexedDBOptions {
-    /**
-     * The version of the database. Changing this triggers an upgrade.
-     * @default 1
-     */
-    version?: number;
-    /**
-     * A callback function executed when the database version changes or is created.
-     * Use this to create or modify object stores.
-     * @param db - The IDBDatabase instance.
-     * @param oldVersion - The previous version of the database.
-     * @param newVersion - The new version of the database.
-     */
-    onUpgradeNeeded?: (db: IDBDatabase, oldVersion: number, newVersion: number) => void;
-}
-/**
- * The return value of the useIndexedDB hook, containing state and methods for interacting with the database.
- * @template T - The type of the data stored.
- */
-interface UseIndexedDBReturn<T> {
-    /** The most recently accessed or modified data item. */
-    data: T | null;
-    /** The error message if an operation failed, or null if successful. */
-    error: string | null;
-    /** Indicates if the database is initializing or an operation is in progress. */
-    loading: boolean;
-    /**
-     * Stores a value in the database under the specified key.
-     * @param key - The unique key for the item.
-     * @param value - The value to store.
-     */
-    setItem: (key: string, value: T) => Promise<void>;
-    /**
-     * Retrieves a value from the database by its key.
-     * @param key - The key of the item to retrieve.
-     * @returns A promise that resolves to the item or null if not found.
-     */
-    getItem: (key: string) => Promise<T | null>;
-    /**
-     * Removes an item from the database by its key.
-     * @param key - The key of the item to remove.
-     */
-    removeItem: (key: string) => Promise<void>;
-    /**
-     * Removes all items from the current object store.
-     */
-    clear: () => Promise<void>;
-    /**
-     * Retrieves all keys currently stored in the object store.
-     * @returns A promise that resolves to an array of keys.
-     */
-    getAllKeys: () => Promise<string[]>;
-}
-/**
- * Custom hook that provides an interface to the [`IndexedDB API`](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API) for client-side storage of significant amounts of structured data.
- *
- * @category storage
- * @template T - The type of the data to be stored.
- * @param {string} databaseName - The name of the IndexedDB database.
- * @param {string} storeName - The name of the object store within the database.
- * @param {UseIndexedDBOptions} [options] - Configuration options for the database connection (optional).
- * @returns {UseIndexedDBReturn<T>} An object containing the current data state, error state, loading state, and methods to interact with the database.
- * @public
- * @example
- * ```tsx
- * interface UserProfile {
- * name: string;
- * age: number;
- * }
- *
- * const { setItem, getItem, data } = useIndexedDB<UserProfile>('myAppDB', 'profiles');
- *
- * const saveProfile = async () => {
- * await setItem('user_1', { name: 'Alice', age: 30 });
- * };
- * ```
- */
-declare function useIndexedDB<T>(databaseName: string, storeName: string, options?: UseIndexedDBOptions): UseIndexedDBReturn<T>;
-
-/** 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.
- * @category sensors
- * @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](/docs/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;
-
-/**
- * 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).
- *
- * @category effect
- * @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](/docs/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;
-
-/**
- * Custom hook that determines if the code is running on the client side (in the browser).
- *
- * @category lifecycle
- * @returns {boolean} A boolean value indicating whether the code is running on the client side.
- * @public
- * @see [Documentation](/docs/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;
-
-/**
- * Custom hook that determines if the component is currently mounted.
- *
- * @category lifecycle
- * @returns {() => boolean} A function that returns a boolean value indicating whether the component is mounted.
- * @public
- * @see [Documentation](/docs/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;
-
-/**
- * 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](/docs/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;
-
-type KbdKeysSpecificMap = {
-    meta: string;
-    alt: string;
-    ctrl: string;
-};
-declare const kbdKeysMap: {
-    readonly meta: "";
-    readonly ctrl: "";
-    readonly alt: "";
-    readonly win: "⊞";
-    readonly command: "⌘";
-    readonly shift: "⇧";
-    readonly control: "⌃";
-    readonly option: "⌥";
-    readonly enter: "↵";
-    readonly delete: "⌦";
-    readonly backspace: "⌫";
-    readonly escape: "Esc";
-    readonly tab: "⇥";
-    readonly capslock: "⇪";
-    readonly arrowup: "↑";
-    readonly arrowright: "→";
-    readonly arrowdown: "↓";
-    readonly arrowleft: "←";
-    readonly pageup: "⇞";
-    readonly pagedown: "⇟";
-    readonly home: "↖";
-    readonly end: "↘";
-};
-type KbdKey = keyof typeof kbdKeysMap;
-type KbdKeySpecific = keyof KbdKeysSpecificMap;
-/**
- * Custom hook that detects the operating system (Mac vs. Windows/Linux) and provides
- * a normalized map of keyboard keys (e.g., mapping "Meta" to "Command" on Mac and "Ctrl" on Windows).
- * * @category utilities
- * @returns {Object} An object containing the OS detection state and a key mapping function.
- * @public
- * @see [Documentation](/docs/hooks/use-kbd)
- * @example
- * ```tsx
- * const { isMac, getKbdKey } = useKbd();
- * * // Returns "⌘" on Mac, "Ctrl" on Windows
- * const metaSymbol = getKbdKey('meta');
- * * return <div>Press {metaSymbol} + C to copy</div>;
- * ```
- */
-declare const useKbd: () => {
-    isMac: boolean;
-    getKbdKey: (value?: KbdKey | string) => string | undefined;
-};
-
-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.
- *
- * @category storage
- * @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](/docs/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];
-
-/**
- * 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.
- *
- * @category state
- * @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](/docs/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>;
-
-/** 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).
- * @category sensors
- * @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](/docs/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;
-
-/**
- * Represents an image associated with the media (e.g., album art).
- */
-interface MediaImage {
-    /** The URL of the image. */
-    src: string;
-    /** The sizes of the image (e.g., "96x96"). */
-    sizes?: string;
-    /** The MIME type of the image (e.g., "image/png"). */
-    type?: string;
-}
-/**
- * Metadata for the current media session.
- */
-interface MediaMetadataInit {
-    /** The title of the media. */
-    title?: string;
-    /** The artist name. */
-    artist?: string;
-    /** The album name. */
-    album?: string;
-    /** An array of artwork images. */
-    artwork?: MediaImage[];
-}
-/**
- * Supported media session actions.
- */
-type MediaSessionAction = "play" | "pause" | "stop" | "seekbackward" | "seekforward" | "seekto" | "skipad" | "previoustrack" | "nexttrack";
-/**
- * The current playback state of the media session.
- */
-type MediaSessionPlaybackState = "none" | "paused" | "playing";
-/**
- * Handler function for media session actions.
- */
-type MediaSessionActionHandler = (details?: any) => void;
-/**
- * Options for the `useMediaSession` hook.
- */
-interface UseMediaSessionOptions {
-    /** Initial metadata to set for the session. */
-    metadata?: MediaMetadataInit;
-    /** Initial playback state. */
-    playbackState?: MediaSessionPlaybackState;
-    /** Initial action handlers to register. */
-    actionHandlers?: Partial<Record<MediaSessionAction, MediaSessionActionHandler>>;
-}
-/**
- * Return value of the `useMediaSession` hook.
- */
-interface UseMediaSessionReturn {
-    /** Whether the Media Session API is supported in the current environment. */
-    isSupported: boolean;
-    /** Function to update the media metadata. */
-    setMetadata: (metadata: MediaMetadataInit) => void;
-    /** Function to update the playback state. */
-    setPlaybackState: (state: MediaSessionPlaybackState) => void;
-    /** Function to set a specific action handler. */
-    setActionHandler: (action: MediaSessionAction, handler: MediaSessionActionHandler | null) => void;
-    /** Function to clear all registered action handlers. */
-    clearActionHandlers: () => void;
-}
-
-/**
- * Custom hook that interacts with the [Media Session API](https://developer.mozilla.org/en-US/docs/Web/API/Media_Session_API).
- * It allows you to customize media notifications and handle media control events (like play, pause, next track) from the system's notification area or lock screen.
- *
- * @category sensors
- * @param options - Initial configuration for the media session.
- * @returns Object containing methods to control the media session and a flag indicating support.
- * @public
- * @example
- * ```tsx
- * const MyPlayer = () => {
- * const { setMetadata, setPlaybackState } = useMediaSession({
- * playbackState: "playing",
- * metadata: {
- * title: "Awesome Song",
- * artist: "Cool Artist",
- * album: "Best Hits",
- * artwork: [{ src: "/album-art.jpg", sizes: "512x512", type: "image/jpeg" }]
- * },
- * actionHandlers: {
- * play: () => console.log("Play clicked"),
- * pause: () => console.log("Pause clicked"),
- * nexttrack: () => console.log("Next track clicked"),
- * }
- * });
- *
- * return <div>Now Playing...</div>;
- * };
- * ```
- */
-declare const useMediaSession: (options?: UseMediaSessionOptions) => UseMediaSessionReturn;
-
-interface NetworkInformation {
-    downlink?: number;
-    downlinkMax?: number;
-    effectiveType?: "2g" | "3g" | "4g" | "slow-2g";
-    rtt?: number;
-    saveData?: boolean;
-    type?: "bluetooth" | "cellular" | "ethernet" | "none" | "wifi" | "wimax" | "other" | "unknown";
-}
-interface UseNetworkInformationReturn {
-    /** Detailed information about the network connection. */
-    networkInfo: NetworkInformation | null;
-    /** Whether the browser detects an internet connection. */
-    isOnline: boolean;
-    /** Whether the Network Information API is supported in this browser. */
-    isSupported: boolean;
-    /** Function to manually update the network information. */
-    refresh: () => void;
-}
-
-declare global {
-    interface Navigator {
-        connection?: NetworkInformation;
-    }
-}
-/**
- * Custom hook that tracks the device's network connection status and details (speed, type)
- * using the Network Information API.
- * @category network
- * @returns {UseNetworkInformationReturn} The network state, connection details, and support status.
- * @public
- * @see [Documentation](/docs/use-network-information)
- * @example
- * ```tsx
- * const { isOnline, networkInfo } = useNetworkInformation();
- * * if (!isOnline) return <div>You are offline</div>;
- * * return (
- * <div>
- * Connection: {networkInfo?.effectiveType} ({networkInfo?.downlink} Mbps)
- * </div>
- * );
- * ```
- */
-declare const useNetworkInformation: () => UseNetworkInformationReturn;
-
-type HTMLElRef = React$1.MutableRefObject<HTMLElement>;
-type CustomEvent$1 = {
-    event?: React$1.SyntheticEvent<any, Event>;
-    portal: HTMLElRef;
-    targetEl: HTMLElRef;
-} & React$1.SyntheticEvent<any, Event>;
-type CustomEventHandler = (customEvent: CustomEvent$1) => void;
-type CustomEventHandlers = {
-    [K in keyof React$1.DOMAttributes<K>]?: CustomEventHandler;
-};
-type EventListenerMap = {
-    [K in keyof React$1.DOMAttributes<K>]: keyof GlobalEventHandlersEventMap;
-};
-type EventListenersRef = React$1.MutableRefObject<{
-    [K in keyof React$1.DOMAttributes<K>]?: (event: React$1.SyntheticEvent<any, Event>) => void;
-}>;
-type UsePortalOptions = {
-    /** Close the portal when clicking outside the portal content. @default true */
-    closeOnOutsideClick?: boolean;
-    /** Close the portal when the Escape key is pressed. @default true */
-    closeOnEsc?: boolean;
-    /** The DOM element to attach the portal to. @default document.body */
-    bindTo?: HTMLElement;
-    /** Initial open state. @default false */
-    isOpen?: boolean;
-    /** Callback fired when the portal opens. */
-    onOpen?: CustomEventHandler;
-    /** Callback fired when the portal closes. */
-    onClose?: CustomEventHandler;
-    /** Callback fired when the portal content is clicked. */
-    onPortalClick?: CustomEventHandler;
-    /** Set to true if managing open state entirely outside this hook. @default false */
-    programmaticallyOpen?: boolean;
-} & CustomEventHandlers;
-type UsePortalObjectReturn = {};
-type UsePortalArrayReturn = [];
-
-declare const errorMessage1 = "You must either add a `ref` to the element you are interacting with or pass an `event` to openPortal(e) or togglePortal(e) when the `programmaticallyOpen` option is not set to `true`.";
-
-/**
- * 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;
-
-/** 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>;
-    /**
-     * 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.
- * @category sensors
- * @param {UseResizeObserverOptions<T>} options - The options for the ResizeObserver.
- * @returns {Size} - The size of the observed element.
- * @public
- * @see [Documentation](/docs/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;
-
-interface User {
-    id: string;
-    roles: string[];
-    [key: string]: any;
-}
-interface UseRoleGuardOptions {
-    /** The user object. If not provided, attempts to read from session storage. */
-    user?: User | null;
-    /** URL to redirect to if access is denied. @default "/unauthorized" */
-    redirectTo?: string;
-    /** Component to render while loading or if unauthorized (not fully implemented in hook logic, mainly for HOCs). */
-    fallbackComponent?: React.ComponentType;
-    /** Callback fired when access is denied. */
-    onUnauthorized?: () => void;
-    /** The key used to fetch user data from sessionStorage. @default "user" */
-    sessionKey?: string;
-}
-interface UseRoleGuardReturn {
-    /** Whether the user has the required roles. */
-    hasAccess: boolean;
-    /** Checks if the user has at least one of the provided roles. */
-    hasAnyRole: (roles: string[]) => boolean;
-    /** Checks if the user has all of the provided roles. */
-    hasAllRoles: (roles: string[]) => boolean;
-    /** Whether user data is being loaded. */
-    isLoading: boolean;
-    /** The current user object. */
-    user: User | null;
-    /** Manually checks access against a specific set of roles. */
-    checkAccess: (requiredRoles: string[]) => boolean;
-    /** Function to trigger the redirect manually. */
-    redirect: () => void;
-}
-
-/**
- * Custom hook for Role-Based Access Control (RBAC).
- * Checks if a user has specific permissions and handles redirection for unauthorized access.
- * * @category state
- * @param {string[]} requiredRoles - The list of roles required to access the resource.
- * @param {UseRoleGuardOptions} [options={}] - Configuration options including user object and redirect paths.
- * @returns {UseRoleGuardReturn} Access status, user data, and role checking utilities.
- * @public
- * @see [Documentation](/docs/use-role-guard)
- * @example
- * ```tsx
- * const { hasAccess, user, isLoading } = useRoleGuard(['admin', 'editor'], {
- * redirectTo: '/login'
- * });
- * * if (isLoading) return <Loader />;
- * if (!hasAccess) return null; // Will redirect automatically
- * * return <AdminPanel user={user} />;
- * ```
- */
-declare function useRoleGuard(requiredRoles: string[], options?: UseRoleGuardOptions): UseRoleGuardReturn;
-
-/**
- * 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;
-
-/** 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.
- *
- * @category dom
- * @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](/docs/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;
-
-/** 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;
-};
-/**
- * A custom hook that locks and unlocks scroll.
- *
- * @category dom
- * @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](/docs/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;
-
-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.
- *
- * @category storage
- * @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](/docs/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];
-
-declare enum Device {
-    Browser = "browser",
-    Server = "server",
-    Native = "native"
-}
-
-interface UseSSRReturn {
-    /** Whether code is running in the browser. */
-    isBrowser: boolean;
-    /** Whether code is running on the server. */
-    isServer: boolean;
-    /** Whether code is running in a Native environment (e.g. React Native). */
-    isNative: boolean;
-    /** The detected device type. */
-    device: Device;
-    /** Whether Web Workers are supported. */
-    canUseWorkers: boolean;
-    /** Whether window.addEventListener is available. */
-    canUseEventListeners: boolean;
-    /** Whether window.screen is available. */
-    canUseViewport: boolean;
-}
-
-declare const weAreServer: () => void;
-/**
- * Custom hook that detects the current environment (Browser, Server, or Native)
- * and capability support (Workers, EventListeners). useful for avoiding hydration mismatches.
- * * @category utilities
- * @returns {UseSSRReturn} Object containing boolean flags for the current environment.
- * @public
- * @see [Documentation](/docs/use-ssr)
- * @example
- * ```tsx
- * const { isBrowser, isServer } = useSSR();
- * * if (isServer) {
- * return <StaticLoader />;
- * }
- * * return <ClientComponent />;
- * ```
- */
-declare const useSSR: () => UseSSRReturn;
-
-/** 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>>;
-};
-/**
- * Custom hook that manages and navigates between steps in a multi-step process.
- *
- * @category state
- * @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](/docs/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];
-
-interface UseSymbolReturn {
-    /** Creates a new unique symbol and adds it to the local registry. */
-    createSymbol: (description?: string) => symbol;
-    /** Returns a symbol from the global symbol registry. */
-    getGlobalSymbol: (key: string) => symbol;
-    /** Returns the key for a global symbol. */
-    getSymbolKey: (symbol: symbol) => string | undefined;
-    /** Checks if a value is a symbol. */
-    isSymbol: (value: any) => value is symbol;
-    /** Gets the description of a symbol. */
-    getDescription: (symbol: symbol) => string | undefined;
-    /** A collection of standard JavaScript well-known symbols. */
-    wellKnownSymbols: {
-        iterator: symbol;
-        asyncIterator: symbol;
-        hasInstance: symbol;
-        isConcatSpreadable: symbol;
-        species: symbol;
-        toPrimitive: symbol;
-        toStringTag: symbol;
-        unscopables: symbol;
-        match: symbol;
-        matchAll: symbol;
-        replace: symbol;
-        search: symbol;
-        split: symbol;
-    };
-    /** Array of symbols created via createSymbol in this instance. */
-    symbols: symbol[];
-    /** Manually adds a symbol to the local registry. */
-    addSymbol: (symbol: symbol) => void;
-    /** Removes a symbol from the local registry. */
-    removeSymbol: (symbol: symbol) => void;
-    /** Clears all symbols from the local registry. */
-    clearSymbols: () => void;
-}
-
-/**
- * Custom hook for managing ES6 Symbols. Provides utilities to create unique symbols,
- * manage a registry of symbols, and access well-known symbols.
- * * @category utilities
- * @returns {UseSymbolReturn} Utilities for creating, retrieving, and managing symbols.
- * @public
- * @see [Documentation](/docs/use-symbol)
- * @example
- * ```tsx
- * const { createSymbol, wellKnownSymbols } = useSymbol();
- * const myId = createSymbol('my-id');
- * * console.log(wellKnownSymbols.iterator); // Symbol(Symbol.iterator)
- * ```
- */
-declare function useSymbol(): UseSymbolReturn;
-
-/** 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 'sse-hooks-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.
- *
- * @category dom
- * @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](/docs/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;
-
-/**
- * Custom hook that handles timeouts in React components using the [`setTimeout API`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout).
- *
- * @category effect
- * @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](/docs/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;
-
-/**
- * Custom hook that manages a boolean toggle state in React components.
- *
- * @category state
- * @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](/docs/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>>];
-
-/**
- * Custom hook that runs a cleanup function when the component is unmounted.
- *
- * @category lifecycle
- * @param {() => void} func - The cleanup function to be executed on unmount.
- * @public
- * @see [Documentation](/docs/use-unmount)
- * @example
- * ```tsx
- * useUnmount(() => {
- *   // Cleanup logic here
- * });
- * ```
- */
-declare function useUnmount(func: () => void): void;
-
-/**
- * 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>;
-
-type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
-type DefineProps<T, BKeys extends keyof T> = Readonly<T> & {
-    readonly [K in BKeys]-?: boolean;
-};
-type NotUndefined<T> = T extends undefined ? never : T;
-type MappedOmit<T, K extends keyof any> = {
-    [P in keyof T as P extends K ? never : P]: T[P];
-};
-type InferDefaults<T> = {
-    [K in keyof T]?: InferDefault<T, T[K]>;
-};
-type NativeType = null | undefined | number | string | boolean | symbol | Function;
-type InferDefault<P, T> = ((props: P) => T & {}) | (T extends NativeType ? T : never);
-type PropsWithDefaults<T, Defaults extends InferDefaults<T>, BKeys extends keyof T> = T extends unknown ? Readonly<MappedOmit<T, keyof Defaults>> & {
-    readonly [K in keyof Defaults as K extends keyof T ? K : never]-?: K extends keyof T ? Defaults[K] extends undefined ? IfAny<Defaults[K], NotUndefined<T[K]>, T[K]> : NotUndefined<T[K]> : never;
-} & {
-    readonly [K in BKeys]-?: K extends keyof Defaults ? Defaults[K] extends undefined ? boolean | undefined : boolean : boolean;
-} : never;
-declare function withDefaults<T, BKeys extends keyof T = never>(props: DefineProps<T, BKeys>, defaults: InferDefaults<T>): PropsWithDefaults<T, InferDefaults<T>, BKeys>;
-
-export { ComputedRefImpl, Dep, Device, EffectFlags, Link, ReactiveFlags, RefImpl, TrackOpTypes, TriggerOpTypes, __DEV__, batch, breakpointsAntDesign, breakpointsBootstrapV5, breakpointsSematic, breakpointsTailwind, breakpointsVuetify, computed, endBatch, errorMessage1, extend, getActiveSub, globalVersion, isArray, isFunction, isIntegerKey, isMap, isObject, isSymbol, kbdKeysMap, ref, refreshComputed, setActiveSub, shouldTrack, startBatch, targetMap, track, useAudioRecorder, useBatteryHook as useBattery, useBoolean, useBreakpoint, useClickAnyWhere, useClickAway, useComputed, useConferenceSystem, useCookie, useCopyToClipboard, useCountdown, useCounter, useDarkMode, useDebounceCallback, useDebounceValue, useDelete, useDocumentTitle, useEventCallback, useEventListener, useFetch, useForkRef, useGet, useHover, useIndexedDB, useIntersectionObserver, useInterval, useIsClient, useIsMounted, useIsomorphicLayoutEffect, useKbd, useLocalStorage, useMap, useMediaQuality, useMediaQuery, useMediaSession, useNetworkInformation, usePost, usePut, useReactive, useReadLocalStorage, useResizeObserver, useRoleGuard, useSSR, useScreen, useScreenShare, useScript, useScrollLock, useSessionStorage, useStep, useSymbol, useTernaryDarkMode, useTimeout, useToggle, useUnmount, useUserMedia, useWindowSize, weAreServer, withDefaults };
-export type { AudioAnalysisData, BatteryState, ComputedGetter, ComputedRef, ComputedSetter, CustomEvent$1 as CustomEvent, CustomEventHandler, CustomEventHandlers, DebouncedState, DebuggerEvent, DebuggerEventExtraInfo, DebuggerOptions, DefineProps, EventListenerMap, EventListenersRef, HTMLElRef, IfAny, KbdKey, KbdKeySpecific, MediaImage, MediaMetadataInit, MediaQuality, MediaSessionAction, MediaSessionActionHandler, MediaSessionPlaybackState, NetworkInformation, QualityPresetTypes, Ref, Subscriber, TernaryDarkMode, TernaryDarkModeOptions, TernaryDarkModeReturn, UseAudioRecorderOptions, UseAudioRecorderReturn, UseClickAwayOptions, UseConferenceSystemOptions, UseConferenceSystemReturns, UseCookieOptions, UseFetchOptions, UseFetchReturn, UseFetchState, UseMediaQualityReturn, UseMediaSessionOptions, UseMediaSessionReturn, UseNetworkInformationReturn, UsePortalArrayReturn, UsePortalObjectReturn, UsePortalOptions, UseRoleGuardOptions, UseRoleGuardReturn, UseSSRReturn, UseScreenShareOptions, UseScreenShareReturn, UseSymbolReturn, UseUserMediaConstraints, UseUserMediaReturn, User, WritableComputedOptions };