ahooks

const useDeepCompareEffect: any;

const useDeepCompareLayoutEffect: any;

const useIsomorphicLayoutEffect: any;

const useUpdateEffect: any;

const useUpdateLayoutEffect: any;

clearCache: (key?: string | string[]) => void;

configResponsive: (config: ResponsiveConfig) => void;

createUpdateEffect: (hook: EffectHookType) => EffectHookType;

useAntdTable: <TData extends Data, TParams extends Params>(
    service: Service<TData, TParams>,
    options?: AntdTableOptions<TData, TParams>
) => AntdTableResult<TData, TParams>;

useAsyncEffect: (
    effect: () => AsyncGenerator<void, void, void> | Promise<void>,
    deps?: DependencyList
) => void;

useBoolean: (defaultValue?: boolean) => [boolean, Actions];

useClickAway: <T extends Event = Event>(
    onClickAway: (event: T) => void,
    target: BasicTarget | BasicTarget[],
    eventName?: DocumentEventKey | DocumentEventKey[]
) => void;

useControllableValue: {
    <T = any>(props: StandardProps<T>): [T, (v: SetStateAction<T>) => void];
    <T = any>(props?: Props, options?: Options<T>): [
        T,
        (v: SetStateAction<T>, ...args: any[]) => void
    ];
};

useCookieState: (
    cookieKey: string,
    options?: Options
) => readonly [
    string,
    (
        newValue: string | ((prevState: State) => State),
        newOptions?: Cookies.CookieAttributes
    ) => void
];

useCountDown: (options?: Options) => readonly [number, FormattedRes];

useCounter: (
    initialValue?: number,
    options?: Options
) => readonly [
    number,
    {
        readonly inc: (delta?: number) => void;
        readonly dec: (delta?: number) => void;
        readonly set: (value: ValueParam) => void;
        readonly reset: () => void;
    }
];

useCreation: <T>(factory: () => T, deps: DependencyList) => T;

useDebounce: <T>(value: T, options?: DebounceOptions) => T;

useDebounceEffect: (
    effect: EffectCallback,
    deps?: DependencyList,
    options?: DebounceOptions
) => void;

useDebounceFn: <T extends noop>(
    fn: T,
    options?: DebounceOptions
) => { run: any; cancel: () => void; flush: () => ReturnType<T> | undefined };

useDocumentVisibility: () => VisibilityState;

useDrag: <T>(data: T, target: BasicTarget, options?: Options) => void;

useDrop: (target: BasicTarget, options?: Options) => void;

useDynamicList: <T>(initialList?: T[]) => {
    list: T[];
    insert: (index: number, item: T) => void;
    merge: (index: number, items: T[]) => void;
    replace: (index: number, item: T) => void;
    remove: (index: number) => void;
    batchRemove: (indexes: number[]) => void;
    getKey: (index: number) => number;
    getIndex: (key: number) => number;
    move: (oldIndex: number, newIndex: number) => void;
    push: (item: T) => void;
    pop: () => void;
    unshift: (item: T) => void;
    shift: () => void;
    sortList: (result: T[]) => T[];
    resetList: (newList: T[]) => void;
};

useEventEmitter: <T = void>() => EventEmitter<T>;

useEventListener: {
    <K extends keyof HTMLElementEventMap>(
        eventName: K,
        handler: (ev: HTMLElementEventMap[K]) => void,
        options?: Options<HTMLElement>
    ): void;
    <K extends keyof ElementEventMap>(
        eventName: K,
        handler: (ev: ElementEventMap[K]) => void,
        options?: Options<Element>
    ): void;
    <K extends keyof DocumentEventMap>(
        eventName: K,
        handler: (ev: DocumentEventMap[K]) => void,
        options?: Options<Document>
    ): void;
    <K extends keyof WindowEventMap>(
        eventName: K,
        handler: (ev: WindowEventMap[K]) => void,
        options?: Options<Window>
    ): void;
    (
        eventName: string,
        handler: (event: Event) => void,
        options?: Options<Window>
    ): void;
    (eventName: string, handler: noop, options: Options<any>): void;
};

useEventTarget: <T, U = T>(
    options?: Options<T, U>
) => readonly [
    T,
    { readonly onChange: (e: EventTarget<U>) => void; readonly reset: () => void }
];

useExternal: (path?: string, options?: Options) => Status;

useFavicon: (href: string) => void;

useFocusWithin: (target: BasicTarget, options?: Options) => boolean;

useFullscreen: (
    target: BasicTarget,
    options?: Options
) => readonly [
    boolean,
    {
        readonly enterFullscreen: () => void;
        readonly exitFullscreen: () => void;
        readonly toggleFullscreen: () => void;
        readonly isEnabled: true;
    }
];

useFusionTable: <TData extends Data, TParams extends Params>(
    service: Service<TData, TParams>,
    options?: FusionTableOptions<TData, TParams>
) => FusionTableResult<TData, TParams>;

useGetState: {
    <S>(initialState: S | (() => S)): [
        S,
        Dispatch<SetStateAction<S>>,
        GetStateAction<S>
    ];
    <S = undefined>(): [S, Dispatch<SetStateAction<S>>, GetStateAction<S>];
};

useHistoryTravel: <T>(
    initialValue?: T,
    maxLength?: number
) => {
    value: T | undefined;
    backLength: number;
    forwardLength: number;
    setValue: (val: T) => void;
    go: (step: number) => void;
    back: () => void;
    forward: () => void;
    reset: (...params: any[]) => void;
};

useHover: (target: BasicTarget, options?: Options) => boolean;

useInfiniteScroll: <TData extends Data>(
    service: Service<TData>,
    options?: InfiniteScrollOptions<TData>
) => {
    data: TData;
    loading: boolean;
    error: Error | undefined;
    loadingMore: boolean;
    noMore: boolean;
    loadMore: () => void;
    loadMoreAsync: () => Promise<TData>;
    reload: () => void;
    reloadAsync: () => Promise<TData>;
    mutate: any;
    cancel: () => void;
};

useInterval: (
    fn: () => void,
    delay?: number,
    options?: { immediate?: boolean }
) => () => void;

useInViewport: (
    target: BasicTarget | BasicTarget[],
    options?: Options
) => readonly [boolean | undefined, number | undefined];

useKeyPress: (
    keyFilter: KeyFilter,
    eventHandler: (event: KeyboardEvent, key: KeyType) => void,
    option?: Options
) => void;

useLatest: <T>(value: T) => any;

useLocalStorageState: <T>(
    key: string,
    options?: Options<T>
) => readonly [T, (value?: SetState<T>) => void];

useLockFn: <P extends any[] = any[], V = any>(
    fn: (...args: P) => Promise<V>
) => (...args: P) => Promise<V | undefined>;

useLongPress: (
    onLongPress: (event: EventType) => void,
    target: BasicTarget,
    { delay, moveThreshold, onClick, onLongPressEnd }?: Options
) => void;

useMap: <K, T>(
    initialValue?: Iterable<readonly [K, T]>
) => readonly [
    Map<K, T>,
    {
        readonly set: (key: K, entry: T) => void;
        readonly setAll: (newMap: Iterable<readonly [K, T]>) => void;
        readonly remove: (key: K) => void;
        readonly reset: () => void;
        readonly get: (key: K) => T | undefined;
    }
];

useMemoizedFn: <T extends noop>(fn: T) => T;

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

useMouse: (target?: BasicTarget) => CursorState;

useMutationObserver: (
    callback: MutationCallback,
    target: BasicTarget,
    options?: MutationObserverInit
) => void;

useNetwork: () => NetworkState;

usePagination: <TData extends Data, TParams extends Params>(
    service: Service<TData, TParams>,
    options?: PaginationOptions<TData, TParams>
) => PaginationResult<TData, TParams>;

usePrevious: <T>(state: T, shouldUpdate?: ShouldUpdateFunc<T>) => T | undefined;

useRafInterval: (
    fn: () => void,
    delay: number | undefined,
    options?: { immediate?: boolean }
) => () => void;

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

useRafTimeout: (fn: () => void, delay: number | undefined) => () => void;

useReactive: <S extends Record<string, any>>(initialState: S) => S;

useRequest: <TData, TParams extends any[]>(
    service: Service<TData, TParams>,
    options?: Options<TData, TParams>,
    plugins?: Plugin<TData, TParams>[]
) => import('./types').Result<TData, TParams>;

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

useResponsive: () => ResponsiveInfo;

useSafeState: {
    <S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>];
    <S = undefined>(): [S, Dispatch<SetStateAction<S>>];
};

useScroll: (
    target?: Target,
    shouldUpdate?: ScrollListenController
) => Position | undefined;

useSelections: <T>(
    items: T[],
    options?: T[] | Options<T>
) => {
    readonly selected: T[];
    readonly noneSelected: boolean;
    readonly allSelected: boolean;
    readonly partiallySelected: boolean;
    readonly setSelected: any;
    readonly isSelected: (item: T) => boolean;
    readonly select: (item: T) => void;
    readonly unSelect: (item: T) => void;
    readonly toggle: (item: T) => void;
    readonly selectAll: () => void;
    readonly unSelectAll: () => void;
    readonly clearAll: () => void;
    readonly toggleAll: () => void;
};

useSessionStorageState: <T>(
    key: string,
    options?: Options<T>
) => readonly [T, (value?: SetState<T>) => void];

useSet: <K>(
    initialValue?: Iterable<K>
) => readonly [
    Set<K>,
    {
        readonly add: (key: K) => void;
        readonly remove: (key: K) => void;
        readonly reset: () => void;
    }
];

useSetState: <S extends Record<string, any>>(
    initialState: S | (() => S)
) => [S, SetState<S>];

useSize: (target: BasicTarget) => Size | undefined;

useTextSelection: (target?: BasicTarget<Document | Element>) => State;

useThrottle: <T>(value: T, options?: ThrottleOptions) => T;

useThrottleEffect: (
    effect: EffectCallback,
    deps?: DependencyList,
    options?: ThrottleOptions
) => void;

useThrottleFn: <T extends noop>(
    fn: T,
    options?: ThrottleOptions
) => { run: any; cancel: () => void; flush: () => ReturnType<T> | undefined };

useTimeout: (fn: () => void, delay?: number) => () => void;

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

useToggle: {
    <T = boolean>(): [boolean, Actions<T>];
    <T>(defaultValue: T): [T, Actions<T>];
    <T, U>(defaultValue: T, reverseValue: U): [T | U, Actions<T | U>];
};

useTrackedEffect: <T extends DependencyList>(
    effect: Effect<T>,
    deps?: [...T]
) => void;

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

useUnmountedRef: () => any;

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

useVirtualList: <T = any>(
    list: T[],
    options: Options<T>
) => readonly [{ index: number; data: T }[], (index: number) => void];

useWebSocket: (socketUrl: string, options?: Options) => Result;

useWhyDidYouUpdate: (componentName: string, props: IProps) => void;