declare module "http" { import * as events from "events"; import * as stream from "stream"; import { URL } from "url"; import { Socket, Server as NetServer } from "net"; // incoming headers will never contain number interface IncomingHttpHeaders { 'accept'?: string; 'accept-language'?: string; 'accept-patch'?: string; 'accept-ranges'?: string; 'access-control-allow-credentials'?: string; 'access-control-allow-headers'?: string; 'access-control-allow-methods'?: string; 'access-control-allow-origin'?: string; 'access-control-expose-headers'?: string; 'access-control-max-age'?: string; 'age'?: string; 'allow'?: string; 'alt-svc'?: string; 'authorization'?: string; 'cache-control'?: string; 'connection'?: string; 'content-disposition'?: string; 'content-encoding'?: string; 'content-language'?: string; 'content-length'?: string; 'content-location'?: string; 'content-range'?: string; 'content-type'?: string; 'cookie'?: string; 'date'?: string; 'expect'?: string; 'expires'?: string; 'forwarded'?: string; 'from'?: string; 'host'?: string; 'if-match'?: string; 'if-modified-since'?: string; 'if-none-match'?: string; 'if-unmodified-since'?: string; 'last-modified'?: string; 'location'?: string; 'pragma'?: string; 'proxy-authenticate'?: string; 'proxy-authorization'?: string; 'public-key-pins'?: string; 'range'?: string; 'referer'?: string; 'retry-after'?: string; 'set-cookie'?: string[]; 'strict-transport-security'?: string; 'tk'?: string; 'trailer'?: string; 'transfer-encoding'?: string; 'upgrade'?: string; 'user-agent'?: string; 'vary'?: string; 'via'?: string; 'warning'?: string; 'www-authenticate'?: string; [header: string]: string | string[] | undefined; } // outgoing headers allows numbers (as they are converted internally to strings) interface OutgoingHttpHeaders { [header: string]: number | string | string[] | undefined; } interface ClientRequestArgs { protocol?: string; host?: string; hostname?: string; family?: number; port?: number | string; defaultPort?: number | string; localAddress?: string; socketPath?: string; method?: string; path?: string; headers?: OutgoingHttpHeaders; auth?: string; agent?: Agent | boolean; _defaultAgent?: Agent; timeout?: number; setHost?: boolean; // https://github.com/nodejs/node/blob/master/lib/_http_client.js#L278 createConnection?: (options: ClientRequestArgs, oncreate: (err: Error, socket: Socket) => void) => Socket; } interface ServerOptions { IncomingMessage?: typeof IncomingMessage; ServerResponse?: typeof ServerResponse; } type RequestListener = (req: IncomingMessage, res: ServerResponse) => void; class Server extends NetServer { constructor(requestListener?: RequestListener); constructor(options: ServerOptions, requestListener?: RequestListener); setTimeout(msecs?: number, callback?: () => void): this; setTimeout(callback: () => void): this; /** * Limits maximum incoming headers count. If set to 0, no limit will be applied. * @default 2000 * {@link https://nodejs.org/api/http.html#http_server_maxheaderscount} */ maxHeadersCount: number | null; timeout: number; /** * Limit the amount of time the parser will wait to receive the complete HTTP headers. * @default 40000 * {@link https://nodejs.org/api/http.html#http_server_headerstimeout} */ headersTimeout: number; keepAliveTimeout: number; } // https://github.com/nodejs/node/blob/master/lib/_http_outgoing.js class OutgoingMessage extends stream.Writable { upgrading: boolean; chunkedEncoding: boolean; shouldKeepAlive: boolean; useChunkedEncodingByDefault: boolean; sendDate: boolean; finished: boolean; headersSent: boolean; connection: Socket; constructor(); setTimeout(msecs: number, callback?: () => void): this; setHeader(name: string, value: number | string | string[]): void; getHeader(name: string): number | string | string[] | undefined; getHeaders(): OutgoingHttpHeaders; getHeaderNames(): string[]; hasHeader(name: string): boolean; removeHeader(name: string): void; addTrailers(headers: OutgoingHttpHeaders | Array<[string, string]>): void; flushHeaders(): void; } // https://github.com/nodejs/node/blob/master/lib/_http_server.js#L108-L256 class ServerResponse extends OutgoingMessage { statusCode: number; statusMessage: string; writableFinished: boolean; constructor(req: IncomingMessage); assignSocket(socket: Socket): void; detachSocket(socket: Socket): void; // https://github.com/nodejs/node/blob/master/test/parallel/test-http-write-callbacks.js#L53 // no args in writeContinue callback writeContinue(callback?: () => void): void; writeHead(statusCode: number, reasonPhrase?: string, headers?: OutgoingHttpHeaders): this; writeHead(statusCode: number, headers?: OutgoingHttpHeaders): this; } interface InformationEvent { statusCode: number; statusMessage: string; httpVersion: string; httpVersionMajor: number; httpVersionMinor: number; headers: IncomingHttpHeaders; rawHeaders: string[]; } // https://github.com/nodejs/node/blob/master/lib/_http_client.js#L77 class ClientRequest extends OutgoingMessage { connection: Socket; socket: Socket; aborted: number; constructor(url: string | URL | ClientRequestArgs, cb?: (res: IncomingMessage) => void); readonly path: string; abort(): void; onSocket(socket: Socket): void; setTimeout(timeout: number, callback?: () => void): this; setNoDelay(noDelay?: boolean): void; setSocketKeepAlive(enable?: boolean, initialDelay?: number): void; addListener(event: 'abort', listener: () => void): this; addListener(event: 'connect', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this; addListener(event: 'continue', listener: () => void): this; addListener(event: 'information', listener: (info: InformationEvent) => void): this; addListener(event: 'response', listener: (response: IncomingMessage) => void): this; addListener(event: 'socket', listener: (socket: Socket) => void): this; addListener(event: 'timeout', listener: () => void): this; addListener(event: 'upgrade', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this; addListener(event: 'close', listener: () => void): this; addListener(event: 'drain', listener: () => void): this; addListener(event: 'error', listener: (err: Error) => void): this; addListener(event: 'finish', listener: () => void): this; addListener(event: 'pipe', listener: (src: stream.Readable) => void): this; addListener(event: 'unpipe', listener: (src: stream.Readable) => void): this; addListener(event: string | symbol, listener: (...args: any[]) => void): this; on(event: 'abort', listener: () => void): this; on(event: 'connect', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this; on(event: 'continue', listener: () => void): this; on(event: 'information', listener: (info: InformationEvent) => void): this; on(event: 'response', listener: (response: IncomingMessage) => void): this; on(event: 'socket', listener: (socket: Socket) => void): this; on(event: 'timeout', listener: () => void): this; on(event: 'upgrade', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this; on(event: 'close', listener: () => void): this; on(event: 'drain', listener: () => void): this; on(event: 'error', listener: (err: Error) => void): this; on(event: 'finish', listener: () => void): this; on(event: 'pipe', listener: (src: stream.Readable) => void): this; on(event: 'unpipe', listener: (src: stream.Readable) => void): this; on(event: string | symbol, listener: (...args: any[]) => void): this; once(event: 'abort', listener: () => void): this; once(event: 'connect', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this; once(event: 'continue', listener: () => void): this; once(event: 'information', listener: (info: InformationEvent) => void): this; once(event: 'response', listener: (response: IncomingMessage) => void): this; once(event: 'socket', listener: (socket: Socket) => void): this; once(event: 'timeout', listener: () => void): this; once(event: 'upgrade', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this; once(event: 'close', listener: () => void): this; once(event: 'drain', listener: () => void): this; once(event: 'error', listener: (err: Error) => void): this; once(event: 'finish', listener: () => void): this; once(event: 'pipe', listener: (src: stream.Readable) => void): this; once(event: 'unpipe', listener: (src: stream.Readable) => void): this; once(event: string | symbol, listener: (...args: any[]) => void): this; prependListener(event: 'abort', listener: () => void): this; prependListener(event: 'connect', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this; prependListener(event: 'continue', listener: () => void): this; prependListener(event: 'information', listener: (info: InformationEvent) => void): this; prependListener(event: 'response', listener: (response: IncomingMessage) => void): this; prependListener(event: 'socket', listener: (socket: Socket) => void): this; prependListener(event: 'timeout', listener: () => void): this; prependListener(event: 'upgrade', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this; prependListener(event: 'close', listener: () => void): this; prependListener(event: 'drain', listener: () => void): this; prependListener(event: 'error', listener: (err: Error) => void): this; prependListener(event: 'finish', listener: () => void): this; prependListener(event: 'pipe', listener: (src: stream.Readable) => void): this; prependListener(event: 'unpipe', listener: (src: stream.Readable) => void): this; prependListener(event: string | symbol, listener: (...args: any[]) => void): this; prependOnceListener(event: 'abort', listener: () => void): this; prependOnceListener(event: 'connect', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this; prependOnceListener(event: 'continue', listener: () => void): this; prependOnceListener(event: 'information', listener: (info: InformationEvent) => void): this; prependOnceListener(event: 'response', listener: (response: IncomingMessage) => void): this; prependOnceListener(event: 'socket', listener: (socket: Socket) => void): this; prependOnceListener(event: 'timeout', listener: () => void): this; prependOnceListener(event: 'upgrade', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => void): this; prependOnceListener(event: 'close', listener: () => void): this; prependOnceListener(event: 'drain', listener: () => void): this; prependOnceListener(event: 'error', listener: (err: Error) => void): this; prependOnceListener(event: 'finish', listener: () => void): this; prependOnceListener(event: 'pipe', listener: (src: stream.Readable) => void): this; prependOnceListener(event: 'unpipe', listener: (src: stream.Readable) => void): this; prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; } class IncomingMessage extends stream.Readable { constructor(socket: Socket); httpVersion: string; httpVersionMajor: number; httpVersionMinor: number; complete: boolean; connection: Socket; headers: IncomingHttpHeaders; rawHeaders: string[]; trailers: { [key: string]: string | undefined }; rawTrailers: string[]; setTimeout(msecs: number, callback?: () => void): this; /** * Only valid for request obtained from http.Server. */ method?: string; /** * Only valid for request obtained from http.Server. */ url?: string; /** * Only valid for response obtained from http.ClientRequest. */ statusCode?: number; /** * Only valid for response obtained from http.ClientRequest. */ statusMessage?: string; socket: Socket; destroy(error?: Error): void; } interface AgentOptions { /** * Keep sockets around in a pool to be used by other requests in the future. Default = false */ keepAlive?: boolean; /** * When using HTTP KeepAlive, how often to send TCP KeepAlive packets over sockets being kept alive. Default = 1000. * Only relevant if keepAlive is set to true. */ keepAliveMsecs?: number; /** * Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity */ maxSockets?: number; /** * Maximum number of sockets to leave open in a free state. Only relevant if keepAlive is set to true. Default = 256. */ maxFreeSockets?: number; /** * Socket timeout in milliseconds. This will set the timeout after the socket is connected. */ timeout?: number; } class Agent { maxFreeSockets: number; maxSockets: number; readonly sockets: { readonly [key: string]: Socket[]; }; readonly requests: { readonly [key: string]: IncomingMessage[]; }; constructor(opts?: AgentOptions); /** * Destroy any sockets that are currently in use by the agent. * It is usually not necessary to do this. However, if you are using an agent with KeepAlive enabled, * then it is best to explicitly shut down the agent when you know that it will no longer be used. Otherwise, * sockets may hang open for quite a long time before the server terminates them. */ destroy(): void; } const METHODS: string[]; const STATUS_CODES: { [errorCode: number]: string | undefined; [errorCode: string]: string | undefined; }; function createServer(requestListener?: RequestListener): Server; function createServer(options: ServerOptions, requestListener?: RequestListener): Server; // although RequestOptions are passed as ClientRequestArgs to ClientRequest directly, // create interface RequestOptions would make the naming more clear to developers interface RequestOptions extends ClientRequestArgs { } function request(options: RequestOptions | string | URL, callback?: (res: IncomingMessage) => void): ClientRequest; function request(url: string | URL, options: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest; function get(options: RequestOptions | string | URL, callback?: (res: IncomingMessage) => void): ClientRequest; function get(url: string | URL, options: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest; let globalAgent: Agent; /** * Read-only property specifying the maximum allowed size of HTTP headers in bytes. * Defaults to 8KB. Configurable using the [`--max-http-header-size`][] CLI option. */ const maxHeaderSize: number; }