import { DependencyList, Dispatch, SetStateAction } from 'react';
export declare enum DebounceValueStatus {
    DONE = "DONE",
    PENDING = "PENDING"
}
export interface UseDebounceStateFunc {
    <S>(initialState: S | (() => S)): {
        debouncedState: S;
        setState: Dispatch<SetStateAction<S>>;
        actualState: S;
        stop(): void;
        status: keyof typeof DebounceValueStatus;
    };
    <S = undefined>(): {
        debouncedState: S | undefined;
        setState: Dispatch<SetStateAction<S | undefined>>;
        actualState: S | undefined;
        stop(): void;
        status: keyof typeof DebounceValueStatus;
    };
}
export declare const useDebounceState: UseDebounceStateFunc;
export interface UseDebounceFunc {
    <S>(initialState: S | (() => S)): {
        debouncedState: S;
        stop(): void;
        status: keyof typeof DebounceValueStatus;
    };
    <S = undefined>(): {
        debouncedState: S | undefined;
        stop(): void;
        status: keyof typeof DebounceValueStatus;
    };
}
export declare const useDebounce: UseDebounceFunc;
interface BaseUseDebounceConfigOptions {
    /** Millisecond  */
    debounceTime?: number;
}
interface UseDebounceConfigOptionsForPromise<TSuccess> extends BaseUseDebounceConfigOptions {
    /** Promise successful handler */
    onSuccess?(data: TSuccess): void;
    /** Promise reject handler */
    onError?(err: unknown): void;
}
type TypeFromPromise<P> = P extends Promise<infer R> ? R : P;
type UseDebounceConfigOptions<TReturn> = TReturn extends Promise<infer TResolve> ? UseDebounceConfigOptionsForPromise<TResolve> : BaseUseDebounceConfigOptions;
export declare function useDebounceFn<TParams extends unknown[] = any[], TReturn = unknown>(
/** Debounce function */
fn: (...args: TParams) => TReturn, 
/**
 * Additional configuration options
 * onSuccess, onError can be config if the function return a promise
 */
config?: UseDebounceConfigOptions<TReturn>, 
/** Function with use callback also available, just pass dependency here, run function automatically wrapped inside useCallback
 * with your all dependencies
 */
deps?: DependencyList): {
    /** Return data of whole progress */
    returnedData: TypeFromPromise<TReturn> | undefined;
    /** Control only pending time */
    status: "DONE" | "PENDING";
    /** Control whole state include debounce pending time + promise pending time */
    progressStatus: "DONE" | "PENDING";
    /** Run debounce function */
    run: (...args: TParams) => void;
    /** stop debounce progress */
    stop: () => void;
};
export {};