import * as react_jsx_runtime from 'react/jsx-runtime';
import PQueue from 'p-queue';
import React from 'react';

interface Identifiable {
    [key: string]: any;
}
type PQResolverResult<T, E = any> = {
    data: T | null;
    error?: E | null;
};
type TaskPayload<P> = P;
type PQSingleResolver<T, P> = (task: TaskPayload<P>) => Promise<PQResolverResult<T>>;
type PQBatchResolver<T, P> = (...task: TaskPayload<P>[]) => Promise<PQResolverResult<T[]>>;
type PQConfig<T> = {
    /**
     * The maximum size of the resolved data saved within the memory. set falsy (0 | -1 | false | null) for no limit.
     * This is to prevent memory leak when handling with huge queue that will be keep being triggered.
     */
    identifier: keyof T;
};
type TResolverByBatch<B, T, P> = B extends true ? PQBatchResolver<T, P> : PQSingleResolver<T, P>;
type QueueProviderProps<T, P> = {
    config: PQConfig<T>;
    queue: PQueue;
} & ({
    /**
     * batch size
     */
    batch: number;
    /**
     * throttle time in ms
     */
    throttle: number;
    resolver: TResolverByBatch<true, T, P>;
} | {
    batch?: null | false;
    throttle?: null | false;
    resolver: TResolverByBatch<false, T, P>;
});
declare function QueueProvider<T extends Identifiable, P extends Identifiable>({ config, resolver, batch, throttle, queue, children, }: React.PropsWithChildren<QueueProviderProps<T, P>>): react_jsx_runtime.JSX.Element;
type PQAddDispatcher<T, P> = (task: P) => Promise<PQResolverResult<T>>;
type PQClearDispatcher = () => void;
type UseQueueReturnType<T, P> = {
    add: PQAddDispatcher<T, P>;
    clear: PQClearDispatcher;
};
declare function useQueueStore<T, P>(): PQResolverResult<T, any>[];
declare function useQueue<T, P>(): UseQueueReturnType<T, P>;

export { QueueProvider as default, useQueue, useQueueStore };