export interface IHttpRequest<T = unknown> {
    url: string;
    method: string;
    body: T;
    headers: Record<string, string>;
    metadata: Record<symbol, unknown>;
}
export interface IUploadProgressData {
    loaded: number;
    total: number;
}
export interface IUploadRequest<T extends Blob = Blob> extends IHttpRequest<T> {
    onProgress?(e: IUploadProgressData): void;
}
export interface IHttpResponse<T = unknown> {
    body: T;
    headers: {
        get(key: string): string | null;
        has(key: string): boolean;
    };
    status: number;
    statusText: string;
}
/**
 * HTTP error containing request object and response object if server has answered.
 */
export declare class HttpRequestError<T> extends Error {
    req: IHttpRequest;
    res: IHttpResponse<T> | null;
    constructor(req: IHttpRequest, res: IHttpResponse<T> | null);
}
/**
 * Request interceptor.
 * It can modify request object before sending.
 */
export declare type RequestInterceptor = (req: IHttpRequest) => void;
/**
 * HTTP error handler.
 * It can deal with errors and retry sending request.
 * If retry is called without request argument, same request object will be used.
 */
export declare type ErrorHandler = (req: HttpRequestError<unknown>, retry: (req?: IHttpRequest) => Promise<IHttpResponse<unknown>>) => Promise<IHttpResponse<unknown> | null>;
export default abstract class HttpClient {
    protected requestInterceptors: {
        items: RequestInterceptor[];
        add(item: RequestInterceptor): void;
        remove(item: RequestInterceptor): void;
    };
    protected errorHandlers: {
        items: ErrorHandler[];
        add(item: ErrorHandler): void;
        remove(item: ErrorHandler): void;
    };
    /**
     * Actual request sending implementation.
     * @param req request data object
     */
    protected abstract sendRequest<T>(req: IHttpRequest): Promise<IHttpResponse<T>>;
    /**
     * Actual file uploading request implementation.
     * @param req request data
     */
    protected abstract sendFile<T>(req: IUploadRequest): Promise<IHttpResponse<T>>;
    private handleError;
    private pipeRequest;
    /**
     * Send HTTP request.
     * @param url request url
     * @param method request method
     * @param body request body
     * @param headers request headers
     * @param metadata request metadata (for internal usage, doesn't provide anything meaningful for the request itself)
     * @returns response object
     * @throws {HttpRequestError} on 4xx or 5xx status code
     */
    fetch<T>(url: string, method: string, body?: unknown, headers?: Record<string, string>, metadata?: Record<symbol, unknown>): Promise<IHttpResponse<T>>;
    /**
     * Upload file via HTTP.
     * @param url request url
     * @param data file (request body)
     * @param method request method
     * @param headers request headers
     * @param metadata request metadata (for internal usage, doesn't provide anything meaningful for the request itself)
     * @param onProgress upload progress event callback
     * @returns response object
     * @throws {HttpRequestError} on 4xx or 5xx status code
     */
    upload<T>(url: string, data: Blob, { onProgress, method, headers, metadata, }?: {
        onProgress?(e: IUploadProgressData): void;
        method?: string;
        headers?: Record<string, string>;
        metadata?: Record<symbol, unknown>;
    }): Promise<IHttpResponse<T>>;
    /**
     * Add request interceptor. It can be used to modify request before sending.
     * You can provide Authorization header here, for example.
     * @param fn request interceptor
     * @returns this
     */
    addRequestInterceptor(fn: RequestInterceptor): this;
    /**
     * Remove request interceptor. If there is no interceptor, function silently returns.
     * @param fn request interceptor
     * @returns this
     */
    removeRequestInterceptor(fn: RequestInterceptor): this;
    /**
     * Add HTTP error handler. It can be used for dealing with HTTP errors and optional recovery.
     * You can try to use refresh/remember token and resend request here, for example.
     * @param fn error handler, can return new HTTP response which will be returned to client
     * @returns this
     */
    addErrorHandler(fn: ErrorHandler): this;
    /**
     * Remove error handler. If there is no handler, function silently returns.
     * @param fn error handler
     * @returns this
     */
    removeErrorHandler(fn: ErrorHandler): this;
    get<T>(url: string, headers?: Record<string, string>): Promise<IHttpResponse<T>>;
    post<T>(url: string, body?: unknown, headers?: Record<string, string>): Promise<IHttpResponse<T>>;
    put<T>(url: string, body?: unknown, headers?: Record<string, string>): Promise<IHttpResponse<T>>;
    patch<T>(url: string, body?: unknown, headers?: Record<string, string>): Promise<IHttpResponse<T>>;
    delete<T>(url: string, body?: unknown, headers?: Record<string, string>): Promise<IHttpResponse<T>>;
}