import type BalenaAuth from 'balena-auth';
import type * as Stream from 'stream';
import type * as urlLib from 'node:url';
import { BalenaRequestError, BalenaExpiredToken, BalenaInvalidParameterError } from 'balena-errors';
export { BalenaRequestError, BalenaExpiredToken, BalenaInvalidParameterError };
import type { BalenaRequestStreamProgressEvent } from './progress';
export type { BalenaRequestStreamProgressEvent } from './progress';
export interface BalenaRequestOptions {
    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
    baseUrl?: string;
    uri?: string;
    url: string;
    apiKey?: string;
    sendToken?: boolean;
    refreshToken?: boolean;
    retries?: number;
    body?: any;
    json?: boolean;
    strictSSL?: boolean;
    responseFormat?: 'none' | 'blob' | 'json' | 'text';
    headers?: Record<string, string>;
    signal?: any;
    timeout?: number;
    qs?: any;
    gzip?: boolean;
    followRedirect?: boolean;
}
export interface BalenaRequestResponse<T = any> extends Omit<Response, 'body'> {
    statusCode: number;
    body: T;
    duration: number;
    request: {
        headers: BalenaRequestOptions['headers'];
        uri: urlLib.UrlWithStringQuery;
    };
}
export interface BalenaRequestPassThroughStream extends Stream.PassThrough {
    response: BalenaRequestResponse;
    mime?: string | null;
}
export interface BalenaRequestStreamResult extends Stream.Readable {
    mime: string;
    on(event: 'progress', listener: (event: BalenaRequestStreamProgressEvent | undefined) => void): this;
    on(event: 'close', listener: () => void): this;
    on(event: 'data', listener: (chunk: any) => void): this;
    on(event: 'end', listener: () => void): this;
    on(event: 'error', listener: (err: Error) => void): this;
    on(event: 'pause', listener: () => void): this;
    on(event: 'readable', listener: () => void): this;
    on(event: 'resume', listener: () => void): this;
    on(event: string | symbol, listener: (...args: any[]) => void): this;
}
export interface WebResourceFile extends Blob {
    name: string;
}
export interface Interceptor {
    request?(response: any): Promise<any>;
    response?(response: any): Promise<any>;
    requestError?(error: Error): Promise<any>;
    responseError?(error: Error): Promise<any>;
}
export interface RequestFactoryOptions {
    auth?: BalenaAuth;
    debug?: boolean;
    retries?: number;
    /** @deprecated */
    isBrowser?: boolean;
    interceptors?: Interceptor[];
}
export type BalenaRequest = ReturnType<typeof getRequest>;
/**
 * @module request
 */
/**
 * @summary Creates a new balena-request instance.
 *
 * @param {object} options
 * @param {object} options.auth
 * @param {boolean} options.debug
 * @param {number} options.retries
 * @param {boolean} options.isBrowser
 * @param {array} options.interceptors
 */
export declare function getRequest({ auth, debug, retries, interceptors: $interceptors, }: RequestFactoryOptions): {
    send: <T = any>(options: BalenaRequestOptions) => Promise<BalenaRequestResponse<T>>;
    stream: (options: BalenaRequestOptions) => Promise<BalenaRequestStreamResult>;
    interceptors: Interceptor[];
    refreshToken: ({ baseUrl, }: Pick<BalenaRequestOptions, "baseUrl">) => Promise<string>;
};