import * as react from 'react';
import { DependencyList, EffectCallback, Dispatch, SetStateAction } from 'react';
import { DebounceOptions as DebounceOptions$1, ThrottleOptions } from '@/types';

declare function useAsyncEffect(effect: () => Promise<void>, deps?: DependencyList): void;

declare function useCompareEffect(effect: EffectCallback, deps: DependencyList, depsEqual: (oldDeps: DependencyList, nextDeps: DependencyList) => boolean): void;

declare function useDeepCompareEffect(effect: EffectCallback, deps: DependencyList): void;

interface DebounceOptions {
    wait?: number;
    leading?: boolean;
    trailing?: boolean;
    maxWait?: number;
}

declare function useDebounceEffect(effect: EffectCallback, deps?: DependencyList, debounceOptions?: DebounceOptions): void;

declare type noop$2 = (...args: any) => any;
declare function useDebounceFn<T extends noop$2>(fn: T, options: DebounceOptions$1): {
    run: any;
    cancel: any;
    flush: any;
};

declare function useEffectOnce(effect: EffectCallback): void;

declare type noop$1 = (...args: any) => any;
declare function useThrottleFn<T extends noop$1>(fn: T, options: ThrottleOptions): {
    run: any;
    cancel: any;
    flush: any;
};

declare function useThrottleEffect(effect: EffectCallback, deps: DependencyList, options: ThrottleOptions): void;

declare function useUpdateEffect(effect: EffectCallback, deps?: DependencyList): void;

declare function useCountUpdateEffect(effect: EffectCallback, n: number, deps?: DependencyList): void;

declare function useRangeUpdateEffect(effect: EffectCallback, range: number[], deps?: DependencyList): void;

interface Action$1 {
    toggle: () => void;
    setTrue: () => void;
    setFalse: () => void;
}
declare function useBoolean(initState?: boolean): [boolean, Action$1];

interface cookieType {
    [key: string]: string;
}
interface cookieOPtionsType {
    domain?: string;
    path?: string;
    day?: number;
    secure?: boolean;
    sameSite?: "strict" | "lax" | "none";
}
declare function getCookie(key: string): string;
declare function getAllCookie(): cookieType;
declare function removeCooikeItem(key: string): void;
declare function setCookie(key: string, value: string, options?: cookieOPtionsType): void;

declare function useCookie(key: string, value?: string, defaultOptions?: cookieOPtionsType): (string | react.Dispatch<react.SetStateAction<string>>)[];

declare function useCookies(): {
    getCookie: typeof getCookie;
    setCookie: typeof setCookie;
    removeCooikeItem: typeof removeCooikeItem;
    getAllCookie: typeof getAllCookie;
};

declare type GetStateAction<S> = () => S;
declare function useGetState<S>(initValue: S | (() => S)): [S, Dispatch<SetStateAction<S>>, GetStateAction<S>];

interface Options$1<T> {
    defaultValue?: T | (() => T);
    serializer?: (value: T) => string;
    deserializer?: (value: string) => T;
}
declare function useLocalStorageState<T>(key: string, options: Options$1<T>): (string | T | ((value: any) => void))[];

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

declare function usePrevious<T>(state: T): T;

interface Options<T> {
    defaultValue?: T | (() => T);
    serializer?: (value: T) => string;
    deserializer?: (value: string) => T;
}
declare function useSessionStorageState<T>(key: string, options: Options<T>): (string | T | ((value: any) => void))[];

interface Action<T> {
    add: (key: T) => void;
    remove: (key: T) => void;
    reset: () => void;
}
declare function useSet<T>(initValue?: Iterable<T>): [Set<T>, Action<T>];

declare function useSetState(initialState: any): any[];

declare function useToggle(defaultValue: any, reverseValue: any): any[];

interface paramsType {
    [key: string]: string;
}
interface optionsType {
    navigateMode: "push" | "replace";
}
declare function useUrlState(initParams: paramsType, options: optionsType): any[];

declare function useFirstMountState(): boolean;

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

declare type noop = (...args: any) => any;
declare function useUnmount<T extends noop>(fn: T): void;

declare function useUnmountedRef(): react.MutableRefObject<boolean>;

declare function useEvent(fn: any, deps: any): (...args: any[]) => void;

export { useAsyncEffect, useBoolean, useCompareEffect, useCookie, useCookies, useCountUpdateEffect, useDebounceEffect, useDebounceFn, useDeepCompareEffect, useEffectOnce, useEvent, useFirstMountState, useGetState, useLocalStorageState, useMap, useMount, usePrevious, useRangeUpdateEffect, useSessionStorageState, useSet, useSetState, useThrottleEffect, useThrottleFn, useToggle, useUnmount, useUnmountedRef, useUpdateEffect, useUrlState };