src/third_party/devtools/node_modules/@types/node/http.d.ts - cobalt - Git at Google

 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 | null;
         host?: string | null;
         hostname?: string | null;
         family?: number;
         port?: number | string | null;
         defaultPort?: number | string;
         localAddress?: string;
         socketPath?: string;
         method?: string;
         path?: string | null;
         headers?: OutgoingHttpHeaders;
         auth?: string | null;
         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;
         writeProcessing(): void;
     }

     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;
 }
	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 \| null;
	host?: string \| null;
	hostname?: string \| null;
	family?: number;
	port?: number \| string \| null;
	defaultPort?: number \| string;
	localAddress?: string;
	socketPath?: string;
	method?: string;
	path?: string \| null;
	headers?: OutgoingHttpHeaders;
	auth?: string \| null;
	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;
	writeProcessing(): void;
	}

	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;
	}