/// <reference types="node" />
/// <reference types="node" />
/// <reference types="node" />
/// <reference types="node" />
import { Method } from "../method";
import { URL } from "url";
import { Encoding } from "../encoding";
import { Response, ResponseContext } from "../response";
import { CacheControl } from "../cache-control";
import { Client } from "../client";
import { RequestBuilder } from "../request-builder";
import { Header, MultiValueMapType } from "../header";
import { MediaType } from "../media-type";
import { MultiValueMap } from "../../utils/collections";
import { Cookie } from "../cookie";
import { Entity } from "../../framework/entity";
import { Transform, Writable } from "stream";
import { RequestContext, RequestContextStreaming, RequestInformation } from "../request-context";
import { ClientHttp2Session } from "http2";
export declare abstract class NodeRequest implements RequestBuilder, RequestContextStreaming, RequestInformation {
    protected _url: URL;
    protected _client: Client;
    protected _method: Method;
    protected readonly _abortSignal?: AbortSignal;
    protected readonly headers: MultiValueMap<Header>;
    protected readonly _transformers: Transform[];
    constructor(client: Client, url: URL, abortSignal?: AbortSignal);
    getHeaders(): MultiValueMapType;
    private setHeader;
    accept(mediaType: MediaType): RequestBuilder;
    acceptEncoding(encoding: Encoding): RequestBuilder;
    acceptLanguage(locale: string): RequestBuilder;
    build<T>(method: Method, entity?: Entity<T>): Promise<Response>;
    cacheControl(cacheControl: CacheControl): RequestBuilder;
    cookie(cookie: Cookie): RequestBuilder;
    delete<T>(entity: Entity<T>): Promise<Response>;
    get(): Promise<Response>;
    header(key: string, value: string): RequestBuilder;
    post<T>(entity: Entity<T>): Promise<Response>;
    put<T>(entity: Entity<T>): Promise<Response>;
    protected executePreFilters(request: RequestContext): void;
    protected executePostFilters(request: RequestContext, response: ResponseContext): void;
    private makeRequest;
    protected abstract execute<T>(entity?: Entity<T>): Promise<Response>;
    transform(transform: Transform): void;
    getUrl(): URL;
    getMethod(): Method;
    protected static writeEntity<T>(entity: Entity<T>, sink: Writable, transformers: Transform[], cb: (e: Error) => void): Promise<void>;
}
export declare class Http2NodeRequest extends NodeRequest {
    private readonly _req;
    private readonly _responseHeaders;
    private readonly _error?;
    constructor(client: Client, url: URL, session: ClientHttp2Session, abortSignal?: AbortSignal, error?: Error);
    protected execute<T>(entity?: Entity<T>): Promise<Response>;
    private getPath;
}
export declare class HttpNodeRequest extends NodeRequest {
    private req?;
    protected execute<T>(entity?: Entity<T>): Promise<Response>;
}