react-use

const useBattery: () => UseBatteryState;

const useIsomorphicLayoutEffect: any;

const useMeasure: <E extends Element = Element>() => UseMeasureResult<E>;

const usePromise: UsePromise;

const useSearchParam: UseQueryParam;

const useTitle: (title: string, options?: UseTitleOptions) => void;

const useUpdateEffect: any;

const useVibrate: (
    enabled?: boolean,
    pattern?: VibrationPattern,
    loop?: boolean
) => void;

createBreakpoint: (breakpoints?: { [name: string]: number }) => () => string;

createGlobalState: {
    <S = any>(initialState: IHookStateInitAction<S>): () => [
        S,
        (state: IHookStateSetAction<S>) => void
    ];
    <S = undefined>(): () => [S, (state: IHookStateSetAction<S>) => void];
};

createMemo: <T extends (...args: any) => any>(
    fn: T
) => (...args: Parameters<T>) => ReturnType<T>;

createReducer: <Action, State>(
    ...middlewares: Middleware<Action, State>[]
) => (
    reducer: (state: State, action: Action) => State,
    initialState: State,
    initializer?: (value: State) => State
) => [State, Dispatch<Action>];

createReducerContext: <R extends any>(
    reducer: R,
    defaultInitialState: any
) => readonly [
    () => [any, any],
    ({
        children,
        initialState,
    }: {
        children?: React.ReactNode;
        initialState?: any;
    }) => any,
    any
];

createStateContext: <T>(
    defaultInitialValue: T
) => readonly [
    () => [T, any],
    ({
        children,
        initialValue,
    }: {
        children?: React.ReactNode;
        initialValue?: T;
    }) => any,
    any
];

ensuredForwardRef: <T, P = {}>(
    Component: RefForwardingComponent<T, P>
) => ForwardRefExoticComponent<any>;

useAsync: <T extends FunctionReturningPromise>(
    fn: T,
    deps?: DependencyList
) => import('./useAsyncFn').AsyncState<
    import('./misc/types').PromiseType<ReturnType<T>>
>;

useAsyncFn: <T extends FunctionReturningPromise>(
    fn: T,
    deps?: DependencyList,
    initialState?: StateFromFunctionReturningPromise<T>
) => AsyncFnReturn<T>;

useAsyncRetry: <T>(
    fn: () => Promise<T>,
    deps?: DependencyList
) =>
    | { retry: () => void; loading: boolean; error?: undefined; value?: undefined }
    | { retry: () => void; loading: false; error: Error; value?: undefined }
    | { retry: () => void; loading: true; error?: Error | undefined; value?: T }
    | { retry: () => void; loading: false; error?: undefined; value: T };

useAudio: (
    elOrProps: any
) => readonly [
    any,
    HTMLMediaState,
    {
        play: () => Promise<void> | undefined;
        pause: () => void;
        seek: (time: number) => void;
        volume: (volume: number) => void;
        mute: () => void;
        unmute: () => void;
    },
    any
];

useBeforeUnload: (
    enabled?: boolean | (() => boolean),
    message?: string | undefined
) => void;

useBoolean: (initialValue: boolean) => [boolean, (nextValue?: any) => void];

useClickAway: <E extends Event = Event>(
    ref: RefObject<HTMLElement>,
    onClickAway: (event: E) => void,
    events?: string[]
) => void;

useCookie: (
    cookieName: string
) => [
    string,
    (newValue: string, options?: Cookies.CookieAttributes | undefined) => void,
    () => void
];

useCopyToClipboard: () => [CopyToClipboardState, (value: string) => void];

useCounter: (
    initialValue?: IHookStateInitAction<number>,
    max?: number | null,
    min?: number | null
) => [number, CounterActions];

useCss: (css: object) => string;

useCustomCompareEffect: <TDeps extends DependencyList>(
    effect: EffectCallback,
    deps: TDeps,
    depsEqual: DepsEqualFnType<TDeps>
) => void;

useDebounce: (
    fn: Function,
    ms?: number,
    deps?: DependencyList
) => UseDebounceReturn;

useDeepCompareEffect: (effect: EffectCallback, deps: DependencyList) => void;

useDefault: <TStateType>(
    defaultValue: TStateType,
    initialValue: TStateType | (() => TStateType)
) => readonly [TStateType, any];

useDrop: (options?: DropAreaOptions, args?: never[]) => DropAreaState;

useDropArea: (options?: DropAreaOptions) => [DropAreaBond, DropAreaState];

useEffectOnce: (effect: EffectCallback) => void;

useEnsuredForwardedRef: <T>(
    forwardedRef: MutableRefObject<T>
) => MutableRefObject<T>;

useError: () => (err: Error) => void;

useEvent: <T extends UseEventTarget>(
    name: Parameters<AddEventListener<T>>[0],
    handler?: Parameters<AddEventListener<T>>[1],
    target?: T | Window,
    options?: UseEventOptions<T>
) => void;

useFavicon: (href: string) => void;

useFirstMountState: () => boolean;

useFullscreen: (
    ref: RefObject<Element>,
    enabled: boolean,
    options?: FullScreenOptions
) => boolean;

useGeolocation: (
    options?: PositionOptions | undefined
) => GeoLocationSensorState;

useGetSet: <S>(
    initialState: IHookStateInitAction<S>
) => [get: () => S, set: Dispatch<IHookStateSetAction<S>>];

useGetSetState: <T extends object>(
    initialState?: T
) => [() => T, (patch: Partial<T>) => void];

useHarmonicIntervalFn: (fn: Function, delay?: number | null) => void;

useHash: () => readonly [string, (newHash: string) => void];

useHover: (element: Element) => [React.ReactElement<any>, boolean];

useHoverDirty: (ref: RefObject<Element>, enabled?: boolean) => boolean;

useIdle: (ms?: number, initialState?: boolean, events?: string[]) => boolean;

useIntersection: (
    ref: RefObject<HTMLElement>,
    options: IntersectionObserverInit
) => IntersectionObserverEntry | null;

useInterval: (callback: Function, delay?: number | null | undefined) => void;

useKey: <T extends UseEventTarget>(
    key: KeyFilter,
    fn?: Handler,
    opts?: UseKeyOptions<T>,
    deps?: DependencyList
) => void;

useKeyPress: (keyFilter: KeyFilter) => [boolean, KeyboardEvent | null];

useKeyPressEvent: (
    key: string | KeyFilter,
    keydown?: Handler | null | undefined,
    keyup?: Handler | null | undefined,
    useKeyPress?: (keyFilter: KeyFilter) => [boolean, KeyboardEvent | null]
) => void;

useLatest: <T>(value: T) => { readonly current: T };

useLifecycles: (mount: any, unmount?: any) => void;

useList: <T>(initialList?: IHookStateInitAction<T[]>) => [T[], ListActions<T>];

useLocalStorage: <T>(
    key: string,
    initialValue?: T,
    options?:
        | { raw: true }
        | {
              raw: false;
              serializer: (value: T) => string;
              deserializer: (value: string) => T;
          }
) => [T, Dispatch<SetStateAction<T>>, () => void];

useLocation: () => LocationSensorState;

useLockBodyScroll: (
    _locked?: boolean,
    _elementRef?: RefObject<HTMLElement> | undefined
) => void;

useLogger: (componentName: string, ...rest: any[]) => void;

useLongPress: (
    callback: (e: TouchEvent | MouseEvent) => void,
    { isPreventDefault, delay }?: Options
) => {
    readonly onMouseDown: (e: any) => void;
    readonly onTouchStart: (e: any) => void;
    readonly onMouseUp: () => void;
    readonly onMouseLeave: () => void;
    readonly onTouchEnd: () => void;
};

useMap: <T extends object = any>(initialMap?: T) => [T, Actions<T>];

useMedia: (query: string, defaultState?: boolean | undefined) => boolean;

useMediaDevices: () => {};

useMediatedState: {
    <S = undefined>(
        mediator: StateMediator<S | undefined>
    ): UseMediatedStateReturn<S>;
    <S = any>(
        mediator: StateMediator<S>,
        initialState: S
    ): UseMediatedStateReturn<S>;
};

useMethods: <M, T>(
    createMethods: CreateMethods<M, T>,
    initialState: T
) => [T, WrappedMethods<M>];

useMotion: (initialState?: MotionSensorState) => MotionSensorState;

useMount: (fn: () => void) => void;

useMountedState: () => () => boolean;

useMouse: (ref: RefObject<Element>) => State;

useMouseHovered: (
    ref: RefObject<Element>,
    options?: UseMouseHoveredOptions
) => State;

useMouseWheel: () => number;

useMultiStateValidator: <
    V extends ValidityState,
    S extends MultiStateValidatorStates
>(
    states: S,
    validator: MultiStateValidator<V, S>,
    initialValidity?: V
) => UseStateValidatorReturn<V>;

useNetworkState: (
    initialState?: IHookStateInitAction<IUseNetworkState>
) => IUseNetworkState;

useNumber: (
    initialValue?: IHookStateInitAction<number>,
    max?: number | null,
    min?: number | null
) => [number, CounterActions];

useObservable: {
    <T>(observable$: Observable<T>): T | undefined;
    <T>(observable$: Observable<T>, initialValue: T): T;
};

useOrientation: (initialState?: OrientationState) => OrientationState;

usePageLeave: (onPageLeave: any, args?: never[]) => void;

usePermission: (permissionDesc: IPermissionDescriptor) => IState;

usePinchZoom: (
    ref: RefObject<HTMLElement>
) =>
    | { zoomingState: ZoomState; pinchState: number }
    | { zoomingState: null; pinchState: number };

usePrevious: <T>(state: T) => T | undefined;

usePreviousDistinct: <T>(value: T, compare?: Predicate<T>) => T | undefined;

useQueue: <T>(initialValue?: T[]) => QueueMethods<T>;

useRaf: (ms?: number, delay?: number) => number;

useRafLoop: (
    callback: FrameRequestCallback,
    initiallyActive?: boolean
) => RafLoopReturns;

useRafState: <S>(
    initialState: S | (() => S)
) => [S, Dispatch<SetStateAction<S>>];

useRendersCount: () => number;

useScratch: (
    params?: ScratchSensorParams
) => [(el: HTMLElement | null) => void, ScratchSensorState];

useScroll: (ref: RefObject<HTMLElement>) => State;

useScrollbarWidth: () => number | undefined;

useScrolling: (ref: RefObject<HTMLElement>) => boolean;

useSessionStorage: <T>(
    key: string,
    initialValue?: T,
    raw?: boolean | undefined
) => [T, (value: T) => void];

useSet: <K>(initialSet?: Set<K>) => [Set<K>, Actions<K>];

useSetState: <T extends object>(
    initialState?: T
) => [T, (patch: Partial<T> | ((prevState: T) => Partial<T>)) => void];

useShallowCompareEffect: (effect: EffectCallback, deps: DependencyList) => void;

useSize: (
    element: Element,
    { width, height }?: Partial<State>
) => [React.ReactElement<any>, State];

useSlider: (ref: RefObject<HTMLElement>, options?: Partial<Options>) => State;

useSpeech: (text: string, options: ISpeechOptions) => ISpeechState;

useStartTyping: (onStartTyping: (event: KeyboardEvent) => void) => void;

useStateList: <T>(stateSet?: T[]) => UseStateListReturn<T>;

useStateValidator: <V extends ValidityState, S>(
    state: S,
    validator: StateValidator<V, S>,
    initialState?: V
) => UseStateValidatorReturn<V>;

useStateWithHistory: {
    <S, I extends S>(
        initialState: IHookStateInitAction<S>,
        capacity?: number,
        initialHistory?: I[]
    ): UseStateHistoryReturn<S>;
    <S = undefined>(): UseStateHistoryReturn<S>;
};

useThrottle: <T>(value: T, ms?: number) => T;

useThrottleFn: <T, U extends any[]>(
    fn: (...args: U) => T,
    ms: number | undefined,
    args: U
) => T;

useTimeout: (ms?: number) => UseTimeoutReturn;

useTimeoutFn: (fn: Function, ms?: number) => UseTimeoutFnReturn;

useToggle: (initialValue: boolean) => [boolean, (nextValue?: any) => void];

useTween: (easingName?: string, ms?: number, delay?: number) => number;

useUnmount: (fn: () => any) => void;

useUnmountPromise: () => Race;

useUpdate: () => () => void;

useUpsert: <T>(
    predicate: (a: T, b: T) => boolean,
    initialList?: IHookStateInitAction<T[]>
) => [T[], UpsertListActions<T>];

useVideo: (
    elOrProps: any
) => readonly [
    any,
    HTMLMediaState,
    {
        play: () => Promise<void> | undefined;
        pause: () => void;
        seek: (time: number) => void;
        volume: (volume: number) => void;
        mute: () => void;
        unmute: () => void;
    },
    any
];

useWindowScroll: () => State;

useWindowSize: ({ initialWidth, initialHeight, onChange }?: Options) => {
    width: number;
    height: number;
};