import { CacheCore, TypeCacheRecord, CacheCoreConfig } from './cache-core.js';
import 'idb-keyval';
import './encode-core.js';

declare class RequestCore<Task extends (...args: any) => Promise<any>, TaskError = any, Meta = Record<string, any>> extends CacheCore<Awaited<ReturnType<Task>> | undefined | null, Parameters<Task>> {
    protected _config: TaskManagerCoreConfig<Task, TaskError, Meta>;
    constructor(_config: TaskManagerCoreConfig<Task, TaskError, Meta>);
    protected _retriedOnError: number;
    protected _defaultRequestDetails: RequestDataRecordType<Task>;
    protected _requestDetails: RequestDataRecordType<Task>;
    get requestDetails(): Readonly<{
        value: RequestDataRecordType<Task>;
    }>;
    get meta(): Meta;
    protected _setRequestDetails(updater: (prev: RequestDataRecordType<Task>) => RequestDataRecordType<Task>): void;
    protected _isPrevented({ hash, config: { isInvalidate, isPreProcess }, }: {
        hash: string;
        config: RequestConfigBase<Task, TaskError, Meta>;
    }): boolean;
    protected _requestCore({ parameters, config, }: {
        parameters: Parameters<Task>;
        config: RequestConfigBase<Task, TaskError, Meta>;
    }): Promise<{
        data?: Awaited<ReturnType<Task>> | undefined | null;
        error?: TaskError;
        isError?: boolean;
        createdAt: number;
        updatedAt: number;
        hash: string;
        parameters: Parameters<Task>;
        meta: Meta;
        isPrevented?: boolean;
    } & SharedConfigs>;
    private _try;
    private _error;
    private _finally;
    protected get _isRetryOnError(): boolean;
    protected _isSameRequest(hash: string): boolean;
    reset(): this;
}
type RequestConfigBase<Task extends (...args: any) => Promise<any>, TaskError = any, Meta = Record<string, any>> = RequestEventHandlersType<Task, TaskError, Meta> & Partial<SharedConfigs>;
type RequestConfigs<Task extends (...args: any) => Promise<any>, TaskError = any, Meta = Record<string, any>> = Partial<SharedConfigs> & RequestEventHandlersType<Task, TaskError, Meta>;
type RequestEventHandlersType<Task extends (...args: any) => Promise<any>, TaskError = any, Meta = Record<string, any>> = {
    onCache?: (params: {
        cache?: TypeCacheRecord<Awaited<ReturnType<Task>> | undefined | null>;
        hash: string;
        parameters: Parameters<Task>;
        meta: Meta;
    } & SharedConfigs, instance: RequestCore<Task, TaskError, Meta>) => any;
    onRequest?: (params: {
        parameters: Parameters<Task>;
        hash: string;
        meta: Meta;
    } & SharedConfigs, instance: RequestCore<Task, TaskError, Meta>) => any;
    onSuccess?: (params: {
        data: Awaited<ReturnType<Task>> | undefined | null;
        hash: string;
        parameters: Parameters<Task>;
        meta: Meta;
    } & SharedConfigs, instance: RequestCore<Task, TaskError, Meta>) => any | Promise<any>;
    onError?: (params: {
        error: TaskError;
        hash: string;
        parameters: Parameters<Task>;
        meta: Meta;
    } & SharedConfigs, instance: RequestCore<Task, TaskError, Meta>) => any | Promise<any>;
    onFinally?: (props: {
        data?: Awaited<ReturnType<Task>> | undefined | null;
        error?: TaskError;
        hash: string;
        parameters: Parameters<Task>;
        meta: Meta;
    } & SharedConfigs, instance: RequestCore<Task, TaskError, Meta>) => any | Promise<any>;
};
type TaskManagerInterceptorsType<Task extends (...args: any) => Promise<any>, TaskError = any, Meta = Record<string, any>> = {
    cache?: (props: {
        cache: TypeCacheRecord<Awaited<ReturnType<Task>> | undefined | null> | undefined;
        hash: string;
        parameters: Parameters<Task>;
        config: RequestConfigBase<Task, TaskError, Meta>;
        meta: Meta;
    } & SharedConfigs, instance: RequestCore<Task, TaskError, Meta>) => Promise<{
        isIgnored?: boolean;
        cache: TypeCacheRecord<Awaited<ReturnType<Task>> | undefined | null> | undefined;
    }>;
    request?: (props: {
        parameters: Parameters<Task>;
        config: RequestConfigBase<Task, TaskError, Meta>;
        hash: string;
        meta: Meta;
    } & SharedConfigs, instance: RequestCore<Task, TaskError, Meta>) => Promise<{
        isPrevented?: boolean;
        parameters: Parameters<Task>;
    }>;
    success?: (props: {
        parameters: Parameters<Task>;
        config: RequestConfigBase<Task, TaskError, Meta>;
        data: Awaited<ReturnType<Task>> | undefined | null;
        hash: string;
        meta: Meta;
    } & SharedConfigs, instance: RequestCore<Task, TaskError, Meta>) => Promise<{
        isIgnored?: boolean;
        data: Awaited<ReturnType<Task>> | undefined | null;
    }>;
    error?: (props: {
        parameters: Parameters<Task>;
        config: RequestConfigBase<Task, TaskError, Meta>;
        error: TaskError;
        hash: string;
        meta: Meta;
    } & SharedConfigs, instance: RequestCore<Task, TaskError, Meta>) => Promise<{
        isIgnored?: boolean;
        error: TaskError;
    }>;
    finally?: (props: {
        parameters: Parameters<Task>;
        config: RequestConfigBase<Task, TaskError, Meta>;
        data: Awaited<ReturnType<Task>> | undefined | null;
        error: TaskError | undefined;
        hash: string;
        meta: Meta;
    } & SharedConfigs, instance: RequestCore<Task, TaskError, Meta>) => Promise<{
        isIgnored?: boolean;
        data?: Awaited<ReturnType<Task>> | undefined | null;
        error?: TaskError;
    }>;
};
type SharedConfigs = {
    isPreProcess: boolean | undefined;
    isInvalidate: boolean | undefined;
};
type TaskManagerCoreConfig<Task extends (...args: any) => Promise<any>, TaskError = any, Meta = Record<string, any>> = {
    handler: Task;
    retryOnError?: number;
    retryOnErrorDelay?: number;
    preventNewRequestDuration?: number;
    defaultEventHandlers?: RequestEventHandlersType<Task, TaskError, Meta>;
    interceptors?: TaskManagerInterceptorsType<Task, TaskError, Meta>;
    meta?: Meta;
    cache?: CacheCoreConfig;
};
type RequestDataRecordType<Task extends (...args: any) => Promise<any>> = {
    parameters?: Parameters<Task>;
    hash?: string;
    createdAt?: number;
    updatedAt?: number;
    isRequested?: boolean;
    isSucceed?: boolean;
    isCached?: boolean;
    isBlocked?: boolean;
    isFailed?: boolean;
    status?: RequestStatus;
    procedure?: RequestStatus[];
    error?: any;
    data?: Awaited<ReturnType<Task>> | null;
    cache?: TypeCacheRecord<Awaited<ReturnType<Task>> | undefined | null>;
};
type RequestStatus = "requested" | "began" | "succeed" | "cached" | "blocked" | "failed";

export { type RequestConfigBase, type RequestConfigs, RequestCore, type RequestDataRecordType, type RequestEventHandlersType, type RequestStatus, type SharedConfigs, type TaskManagerCoreConfig, type TaskManagerInterceptorsType };