pluto-http-client
Version:
HTTP client for NodeJS. Inspired in the Java JAX-RS spec so you can expect excellence, versatility and extensibility.
62 lines (61 loc) • 2.9 kB
TypeScript
/// <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>;
}