declare type CachedKeyType = string | number;

declare type noop = (...args: any[]) => void;
declare type Service<R, P extends any[]> = (...args: P) => Promise<R>;
declare type Mutate<R> = (x: R | undefined | ((data: R) => R)) => void;
declare type RequestService = string | {
    [key: string]: any;
};
declare type CombineService<R, P extends any[]> = RequestService | ((...args: P) => RequestService) | Service<R, P>;
interface FetchResult<R, P extends any[]> {
    loading: boolean;
    data: R | undefined;
    error: Error | undefined;
    params: P;
    cancel: noop;
    refresh: () => Promise<R>;
    mutate: Mutate<R>;
    run: (...args: P) => Promise<R>;
    unmount: () => void;
}
interface BaseResult<R, P extends any[]> extends FetchResult<R, P> {
    reset?: () => void;
    fetches: {
        [key in string]: FetchResult<R, P>;
    };
}
declare type BaseOptions<R, P extends any[]> = {
    refreshDeps?: ReadonlyArray<any>;
    manual?: boolean;
    onSuccess?: (data: R, params: P) => void;
    onError?: (e: Error, params: P) => void;
    defaultLoading?: boolean;
    loadingDelay?: number;
    defaultParams?: P;
    pollingInterval?: number;
    pollingWhenHidden?: boolean;
    fetchKey?: (...args: P) => string;
    paginated?: false;
    loadMore?: false;
    refreshOnWindowFocus?: boolean;
    focusTimespan?: number;
    cacheKey?: CachedKeyType;
    cacheTime?: number;
    staleTime?: number;
    debounceInterval?: number;
    throttleInterval?: number;
    initialData?: R;
    requestMethod?: (service: any) => Promise<any>;
    ready?: boolean;
    throwOnError?: boolean;
};

declare function useRequest<R = any, P extends any[] = any>(service: CombineService<R, P>, options?: BaseOptions<R, P>): BaseResult<R, P>;

export { useRequest };