import type { AxiosError } from 'axios';
import type { AxiosInstance } from 'axios';
import type { AxiosRequestConfig } from 'axios';
import type { AxiosResponse } from 'axios';
import type { CancelToken } from 'axios';
import type { CancelTokenSource } from 'axios';

/**
 * AxiosExtend class
 *
 * @return Promise
 */
declare class AxiosExtend {
    axiosInstance: AxiosInstance;
    waiting: WaitingList;
    retries: number;
    unique: AxiosExtendConfig['unique'];
    orderly: AxiosExtendConfig['orderly'];
    onCancel: AxiosExtendConfig['onCancel'] | null;
    constructor({ orderly, unique, retries, onCancel, ...defaultOptions }: AxiosExtendConfig);
    /**
     * Initialization
     */
    init(defaultOptions: AxiosExtendConfig): void;
    /**
     * Create request
     */
    create<T = any, R = AxiosResponse<T>, D = any>(config: AxiosExtendRequestOptions<D>): Promise<R>;
    /**
     * Drop all un-need requests
     *
     * @param key - the key of waiting line, usually to be the request url
     */
    clear(key?: string): void;
    /**
     * Waiting to resolve the item before this request
     *
     * @param key - the key of waiting line, usually to be the request url
     * @param promiseKey - the unique promise key
     * @returns - Promise<void>
     */
    private wait;
    /**
     * set item to waiting list
     *
     * @param key - the key of waiting line, usually to be the request url
     * @param item - waiting object
     */
    private add;
}
export { AxiosExtend }
export default AxiosExtend;

export declare interface AxiosExtendConfig<D = any> extends AxiosRequestConfig<D> {
    unique?: boolean;
    retries?: number;
    orderly?: boolean;
    shouldResetTimeout?: boolean;
    retryCondition?(): boolean;
    retryDelay?(retryNumber: number, error: any): number;
    setHeaders?(instance: AxiosInstance): void;
    onRequest?(config: AxiosRequestConfig, requestOptions: AxiosExtendRequestOptions): AxiosRequestConfig | Promise<AxiosRequestConfig>;
    onRequestError?(error: any): void;
    onResponse?(res: AxiosResponse<any>, requestOptions: AxiosExtendRequestOptions): AxiosResponse<any> | Promise<AxiosResponse<any>>;
    onResponseError?(error: any): void;
    onError?(error: any): void;
    onCancel?(error: any): void;
}

export declare interface AxiosExtendCurrentStateType {
    lastRequestTime: number;
    retryCount: number;
}

export declare interface AxiosExtendRequestOptions<D = any> extends AxiosRequestConfig<D> {
    ['axios-extend']?: any;
    unique?: boolean;
    orderly?: boolean;
    requestOptions?: AxiosExtendRequestOptions;
    cancelToken?: CancelToken;
    type?: string;
    error?: boolean;
}

/**
 * @param retryNumber - default: 0
 * @return delay milliseconds
 */
export declare function exponentialDelay(retryNumber?: number): number;

/**
 * @param error - Error
 * @return boolean
 */
export declare function isIdempotentRequestError(error: any): boolean;

/**
 * @param error - Error
 * @return boolean
 */
export declare function isNetworkError(error: AxiosError): boolean;

/**
 * @param error - Error
 * @return boolean
 */
export declare function isNetworkOrIdempotentRequestError(error: AxiosError): boolean;

/**
 * @param error - Error
 * @return boolean
 */
export declare function isRetryableError(error: AxiosError): boolean;

/**
 * @param error - Error
 * @return boolean
 */
export declare function isSafeRequestError(error: any): boolean;

export declare interface WaitingItem {
    promiseKey: symbol;
    url: string;
    promise: Promise<any>;
    source: CancelTokenSource;
    abortController?: AbortController;
}

export declare type WaitingList = Record<string, WaitingItem[]>;

export { }