import type { AnyFunc, MakeRequired, NormalObject, ReturnVoid } from '@vunk/shared';
import type { EventSourceMessage } from 'eventsource-parser';
export declare class RestFetch {
    baseURL: RestFetchConstructorOptions['baseURL'];
    setRequestInit: RestFetchConstructorOptions['setRequestInit'];
    presetRequestInit: RestFetchConstructorOptions['presetRequestInit'];
    responseThen: RestFetchConstructorOptions['responseThen'];
    requestThen: RestFetchConstructorOptions['requestThen'];
    timeout: RestFetchConstructorOptions['timeout'];
    ontimeout: RestFetchConstructorOptions['ontimeout'];
    ignoreFetchStatusError: RestFetchConstructorOptions['ignoreFetchStatusError'];
    protected caches: Record<string, Promise<Response>>;
    protected queues: Record<string, {
        promise: Promise<Response>;
        abortController: AbortController;
    }[]>;
    /**
     * 中间件队列
     */
    protected middlewareQueue: RestFetchMiddleware[];
    runMiddlewares(ctx: any, index?: number): Promise<void>;
    constructor(options: RestFetchConstructorOptions);
    use(plugin: RestFetchPlugin, ...args: any[]): any;
    response(options: RestFetchRequestOptions, requestInit?: RequestInit): Promise<any>;
    request(options: RestFetchRequestOptions, state?: NormalObject, requestInit?: RequestInit): Promise<any>;
    download(downloadOpts: {
        url: string;
        fileName?: string;
        overwriteName?: boolean;
    }, options?: Partial<RestFetchRequestOptions>, requestInit?: RequestInit): Promise<void>;
    reader(readerOpts: {
        url: string;
        onmessage: RestFetchReaderOnmessage;
        abortController?: AbortController;
        returnResponse?: boolean;
    }, requestOptions?: Partial<RestFetchRequestOptions>, requestInit?: RequestInit): Promise<Response>;
    resolve(options: RestFetchRequestOptions, state?: NormalObject): Promise<[string, MakeRequired<RestFetchRequestOptions, "abortController">, RequestInit]>;
    private initFetch;
    private resolveRequestInit;
    private middlewareRun;
    addMiddleware(fn: RestFetchMiddleware): void;
    removeMiddleware(fn: RestFetchMiddleware): void;
}
export type RestFetchPlugin = (restFetch: RestFetch, ...args: any) => any;
type ContentType = 'application/json' | 'application/x-www-form-urlencoded' | 'multipart/form-data';
export interface RestFetchMiddlewareContext<S = NormalObject> {
    /**
     * 请求参数
     */
    req: {
        /**
         * request 参数
         */
        requestOptions: RestFetchRequestOptions;
        /**
         * 原生请求参数
         */
        requestInit?: RequestInit;
    };
    res: {
        /**
         * this.response 返回值
         */
        response?: any;
        /**
         * 请求失败
         */
        reason?: any;
        /**
         * 返回 respose Promise
         */
        when: () => Promise<any>;
    };
    /**
     * 中间件提供的参数
     */
    state: S;
    /**
     * 接口返回值
     */
    body: any;
}
export interface RestFetchMiddleware<S = NormalObject> {
    (ctx: RestFetchMiddlewareContext<S>, next: () => Promise<any>): Promise<any>;
}
/**
 * RestFetch 构造函数参数
 */
export interface RestFetchConstructorOptions {
    baseURL: string;
    /**
     * 请求拦截 在  setRequestInit 和 requestInterceptorQueue 之前
     */
    presetRequestInit?: (config: RequestInit) => RequestInit;
    /**
     * 请求拦截 设置 RequestInit
     */
    setRequestInit?: (config: RequestInit) => RequestInit;
    /**
     * 响应拦截
     * @default res => res.json()
     */
    responseThen?: (res: Response) => any;
    /**
     * 响应拦截, 发生在 responseThen 之后
     * @default res => res
     */
    requestThen?: AnyFunc;
    /**
     * 默认超时时间
     * 单位 ms
     */
    timeout?: number;
    /**
     * 超时回调
     */
    ontimeout?: (config: RequestInit) => ReturnVoid;
    /**
     * 跳过 fetch 状态码错误，不抛出异常 可在中间件中处理
     */
    ignoreFetchStatusError?: boolean;
}
/**
 * restFetch.request 参数
 */
export interface RestFetchRequestOptions {
    /**
     * 请求地址
     * baseURL + url
     */
    url: string;
    /**
     * 覆盖 RestFetchConstructorOptions 的 baseURL
     */
    baseURL?: string;
    method: 'POST' | 'GET' | 'PUT' | 'DELETE';
    /**
     * 请求参数
     * 请求体
     */
    data?: Record<string, any>;
    /**
     * 请求参数
     * 请求地址拼接参数
     */
    params?: Record<string, any>;
    /**
     * 请求头
     * @default {}
     */
    headers?: NormalObject;
    /**
     * 请求头
     * @default 'application/json'
     */
    contentType?: ContentType;
    /**
     * 请求拦截 设置 RequestInit
     * 会覆盖 RestFetchConstructorOptions 的 setRequestInit
     *
     */
    setRequestInit?: (config: RequestInit) => RequestInit;
    /**
     * 响应拦截
     * 会覆盖 RestFetchConstructorOptions 的 responseThen
     */
    responseThen?: (res: Response) => any;
    /**
     * 自定义 AbortController
     * timeout 时间到会自动 abort
     * @default new AbortController()
     */
    abortController?: AbortController;
    /**
     * 超时时间
     * 单位 ms
     * 会覆盖 RestFetchConstructorOptions 的 timeout
     */
    timeout?: number;
    /**
     * 超时回调
     * 会覆盖 RestFetchConstructorOptions 的 ontimeout
     */
    ontimeout?: (config: RequestInit) => ReturnVoid;
    /**
     * 设置缓存
     */
    cache?: {
        /**
         * 唯一标识
         */
        id: string;
        /**
         * 是否强制更新
         */
        forceUpdate?: boolean;
    };
    /**
     * 队列
     */
    queue?: {
        /**
         * 唯一标识
         */
        id: string;
        /**
         * 选择模式，
         * abort. 有相同id的请求，打断之前的请后执行
         * wait. 有相同id的请求，等待之前的请求完成后再执行
         * parallel. 仅加入队列，与队列中其他请求并行执行
         *
         */
        mode?: 'abort' | 'wait' | 'parallel';
        /**
         * 是否离开队列
         */
        leave?: boolean;
    };
}
/**
 * restFetch.response
 */
export interface RestFetchResponse {
    (options: RestFetchRequestOptions, requestInit?: RequestInit): Promise<Response>;
}
/**
 * restFetch.request
 */
export interface RestFetchRequest {
    (options: RestFetchRequestOptions, state?: NormalObject, requestInit?: RequestInit): Promise<any>;
}
export type RestFetchReaderOnmessage = (event: EventSourceMessage) => void;
export {};