export declare enum RequestPriority {
    LOW = 0,
    MEDIUM = 1,
    HIGH = 2,
    HIGHEST = 3,
}
export declare enum RequestStatus {
    PENDING = 0,
    SENDING = 1,
    FAILED = 2,
    DONE = 3,
}
export interface Options {
    priority?: RequestPriority;
    responseType?: string;
    body?: string;
    maxRetries?: number;
    auth?: string;
    withCredentials?: boolean;
    headers?: {
        [key: string]: any;
    };
    onProgress?: (evt: ProgressEvent) => void;
}
export declare class RequestQueue {
    retries: number;
    concurrency: number;
    queue: Array<Request>;
    private updateTimeout;
    constructor({retries, concurrency}?: {
        retries?: number;
        concurrency?: number;
    });
    get(url: string, options?: any): Promise<any>;
    head(url: string, options?: any): Promise<any>;
    options(url: string, options?: any): Promise<any>;
    post(url: string, options?: any): Promise<any>;
    put(url: string, options?: any): Promise<any>;
    patch(url: string, options?: any): Promise<any>;
    delete(url: string, options?: any): Promise<any>;
    request(method: string, url: string, options?: any): Promise<any>;
    /**
     * Handle all queue changes, sending new requests etc
     *
     */
    update(): void;
    /**
     * Enqueue a request, adding it to the right place
     * in the queue based on the priority:
     * Highest prioriy first, oldest requests first
     * @private
     * @param {Request} request
     */
    private enqueue(request);
    /**
     * Remove an item from the queue.
     * Usually because the request is done, or it failed.
     * @private
     * @param {Request} req
     */
    private dequeue(req);
    /**
     * Get the next request that is ready to send
     *
     * @private
     * @returns {(Request | null)}
     */
    private getNextPendingRequest();
    /**
     * Get the next request that is currently in flight
     * but pushes us over our concurrency limit
     *
     * @private
     * @returns {(Request | null)}
     */
    private getNextOverflowingRequest();
    /**
     * Handle the actual sending of a request, statuses,
     * retries, error and success callbacks
     *
     * @private
     */
    private sendRequest(req);
}
export declare class Request {
    url: string;
    method: string;
    priority: number;
    maxRetries: number | null;
    responseType: string | null;
    auth: string | null;
    withCredentials: boolean;
    body: string | FormData | null;
    headers: {
        [key: string]: any;
    };
    sendAttempts: number;
    status: RequestStatus;
    promise: Promise<any>;
    onDone: Function;
    onFail: Function;
    onProgress?: (evt: ProgressEvent) => void;
    private xhr;
    /**
     * Creates an instance of Request.
     *
     * @param {string} method
     * @param {string} url
     * @param {any} options: {
     *       priority = RequestPriority.MEDIUM,
     *       responseType = null,
     *       body = null,
     *       auth = null,
     *       maxRetries = null,
     *       headers = {}
     *     }
     */
    constructor(method: string, url: string, options?: Options);
    /**
     * Make and send this XHR
     *
     * @returns {Promise<any>}
     */
    send(): Promise<any>;
    /**
     * Handle parsing the response into JSON or other types,
     * depending on this.responseType
     *
     * @param {*} xhr
     * @returns {*}
     */
    parseResponse(xhr: any): Promise<any>;
    /**
     *
     * Abort this request.
     *
     */
    abort(): void;
}