@types/node 16.11.55 → 16.11.58

node v16.11/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v16.
 
 ### Additional Details
- * Last updated: Tue, 23 Aug 2022 20:32:35 GMT
+ * Last updated: Wed, 07 Sep 2022 20:32:44 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`
 

node v16.11/http.d.ts

@@ -135,12 +135,17 @@ declare module 'http' {
         timeout?: number | undefined;
         setHost?: boolean | undefined;
         // https://github.com/nodejs/node/blob/master/lib/_http_client.js#L278
-        createConnection?: ((options: ClientRequestArgs, oncreate: (err: Error, socket: Socket) => void) => Socket) | undefined;
+        createConnection?:
+            | ((options: ClientRequestArgs, oncreate: (err: Error, socket: Socket) => void) => Socket)
+            | undefined;
         lookup?: LookupFunction | undefined;
     }
-    interface ServerOptions {
-        IncomingMessage?: typeof IncomingMessage | undefined;
-        ServerResponse?: typeof ServerResponse | undefined;
+    interface ServerOptions<
+        Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Response extends typeof ServerResponse = typeof ServerResponse,
+    > {
+        IncomingMessage?: Request | undefined;
+        ServerResponse?: Response | undefined;
         /**
          * Optionally overrides the value of
          * `--max-http-header-size` for requests received by this server, i.e.
@@ -155,14 +160,39 @@ declare module 'http' {
          * @default false
          */
         insecureHTTPParser?: boolean | undefined;
+        /**
+         * If set to `true`, it disables the use of Nagle's algorithm immediately after a new incoming connection is received.
+         * @default false
+         * @since v16.5.0
+         */
+        noDelay?: boolean | undefined;
+        /**
+         * If set to `true`, it enables keep-alive functionality on the socket immediately after a new incoming connection is received,
+         * similarly on what is done in `socket.setKeepAlive([enable][, initialDelay])`.
+         * @default false
+         * @since v16.5.0
+         */
+        keepAlive?: boolean | undefined;
+        /**
+         * If set to a positive number, it sets the initial delay before the first keepalive probe is sent on an idle socket.
+         * @default 0
+         * @since v16.5.0
+         */
+        keepAliveInitialDelay?: number | undefined;
     }
-    type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
+    type RequestListener<
+        Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Response extends typeof ServerResponse = typeof ServerResponse,
+    > = (req: InstanceType<Request>, res: InstanceType<Response> & { req: InstanceType<Request> }) => void;
     /**
      * @since v0.1.17
      */
-    class Server extends NetServer {
-        constructor(requestListener?: RequestListener);
-        constructor(options: ServerOptions, requestListener?: RequestListener);
+    class Server<
+        Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Response extends typeof ServerResponse = typeof ServerResponse,
+    > extends NetServer {
+        constructor(requestListener?: RequestListener<Request, Response>);
+        constructor(options: ServerOptions<Request, Response>, requestListener?: RequestListener<Request, Response>);
         /**
          * Sets the timeout value for sockets, and emits a `'timeout'` event on
          * the Server object, passing the socket as an argument, if a timeout
@@ -256,75 +286,111 @@ declare module 'http' {
         addListener(event: 'connection', listener: (socket: Socket) => void): this;
         addListener(event: 'error', listener: (err: Error) => void): this;
         addListener(event: 'listening', listener: () => void): this;
-        addListener(event: 'checkContinue', listener: RequestListener): this;
-        addListener(event: 'checkExpectation', listener: RequestListener): this;
+        addListener(event: 'checkContinue', listener: RequestListener<Request, Response>): this;
+        addListener(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         addListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
-        addListener(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
-        addListener(event: 'request', listener: RequestListener): this;
-        addListener(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+        addListener(
+            event: 'connect',
+            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
+        ): this;
+        addListener(event: 'request', listener: RequestListener<Request, Response>): this;
+        addListener(
+            event: 'upgrade',
+            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
+        ): this;
         emit(event: string, ...args: any[]): boolean;
         emit(event: 'close'): boolean;
         emit(event: 'connection', socket: Socket): boolean;
         emit(event: 'error', err: Error): boolean;
         emit(event: 'listening'): boolean;
-        emit(event: 'checkContinue', req: IncomingMessage, res: ServerResponse): boolean;
-        emit(event: 'checkExpectation', req: IncomingMessage, res: ServerResponse): boolean;
+        emit(
+            event: 'checkContinue',
+            req: InstanceType<Request>,
+            res: InstanceType<Response> & { req: InstanceType<Request> },
+        ): boolean;
+        emit(
+            event: 'checkExpectation',
+            req: InstanceType<Request>,
+            res: InstanceType<Response> & { req: InstanceType<Request> },
+        ): boolean;
         emit(event: 'clientError', err: Error, socket: stream.Duplex): boolean;
-        emit(event: 'connect', req: IncomingMessage, socket: stream.Duplex, head: Buffer): boolean;
-        emit(event: 'request', req: IncomingMessage, res: ServerResponse): boolean;
-        emit(event: 'upgrade', req: IncomingMessage, socket: stream.Duplex, head: Buffer): boolean;
+        emit(event: 'connect', req: InstanceType<Request>, socket: stream.Duplex, head: Buffer): boolean;
+        emit(
+            event: 'request',
+            req: InstanceType<Request>,
+            res: InstanceType<Response> & { req: InstanceType<Request> },
+        ): boolean;
+        emit(event: 'upgrade', req: InstanceType<Request>, socket: stream.Duplex, head: Buffer): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: 'close', listener: () => void): this;
         on(event: 'connection', listener: (socket: Socket) => void): this;
         on(event: 'error', listener: (err: Error) => void): this;
         on(event: 'listening', listener: () => void): this;
-        on(event: 'checkContinue', listener: RequestListener): this;
-        on(event: 'checkExpectation', listener: RequestListener): this;
+        on(event: 'checkContinue', listener: RequestListener<Request, Response>): this;
+        on(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         on(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
-        on(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
-        on(event: 'request', listener: RequestListener): this;
-        on(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+        on(event: 'connect', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
+        on(event: 'request', listener: RequestListener<Request, Response>): this;
+        on(event: 'upgrade', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: 'close', listener: () => void): this;
         once(event: 'connection', listener: (socket: Socket) => void): this;
         once(event: 'error', listener: (err: Error) => void): this;
         once(event: 'listening', listener: () => void): this;
-        once(event: 'checkContinue', listener: RequestListener): this;
-        once(event: 'checkExpectation', listener: RequestListener): this;
+        once(event: 'checkContinue', listener: RequestListener<Request, Response>): this;
+        once(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         once(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
-        once(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
-        once(event: 'request', listener: RequestListener): this;
-        once(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+        once(
+            event: 'connect',
+            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
+        ): this;
+        once(event: 'request', listener: RequestListener<Request, Response>): this;
+        once(
+            event: 'upgrade',
+            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
+        ): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: 'close', listener: () => void): this;
         prependListener(event: 'connection', listener: (socket: Socket) => void): this;
         prependListener(event: 'error', listener: (err: Error) => void): this;
         prependListener(event: 'listening', listener: () => void): this;
-        prependListener(event: 'checkContinue', listener: RequestListener): this;
-        prependListener(event: 'checkExpectation', listener: RequestListener): this;
+        prependListener(event: 'checkContinue', listener: RequestListener<Request, Response>): this;
+        prependListener(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         prependListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
-        prependListener(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
-        prependListener(event: 'request', listener: RequestListener): this;
-        prependListener(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+        prependListener(
+            event: 'connect',
+            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
+        ): this;
+        prependListener(event: 'request', listener: RequestListener<Request, Response>): this;
+        prependListener(
+            event: 'upgrade',
+            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
+        ): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: 'close', listener: () => void): this;
         prependOnceListener(event: 'connection', listener: (socket: Socket) => void): this;
         prependOnceListener(event: 'error', listener: (err: Error) => void): this;
         prependOnceListener(event: 'listening', listener: () => void): this;
-        prependOnceListener(event: 'checkContinue', listener: RequestListener): this;
-        prependOnceListener(event: 'checkExpectation', listener: RequestListener): this;
+        prependOnceListener(event: 'checkContinue', listener: RequestListener<Request, Response>): this;
+        prependOnceListener(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         prependOnceListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
-        prependOnceListener(event: 'connect', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
-        prependOnceListener(event: 'request', listener: RequestListener): this;
-        prependOnceListener(event: 'upgrade', listener: (req: IncomingMessage, socket: stream.Duplex, head: Buffer) => void): this;
+        prependOnceListener(
+            event: 'connect',
+            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
+        ): this;
+        prependOnceListener(event: 'request', listener: RequestListener<Request, Response>): this;
+        prependOnceListener(
+            event: 'upgrade',
+            listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void,
+        ): this;
     }
     /**
      * This class serves as the parent class of {@link ClientRequest} and {@link ServerResponse}. It is an abstract of outgoing message from
      * the perspective of the participants of HTTP transaction.
      * @since v0.1.17
      */
-    class OutgoingMessage extends stream.Writable {
-        readonly req: IncomingMessage;
+    class OutgoingMessage<Request extends IncomingMessage = IncomingMessage> extends stream.Writable {
+        readonly req: Request;
         chunkedEncoding: boolean;
         shouldKeepAlive: boolean;
         useChunkedEncodingByDefault: boolean;
@@ -461,7 +527,7 @@ declare module 'http' {
      * passed as the second parameter to the `'request'` event.
      * @since v0.1.17
      */
-    class ServerResponse extends OutgoingMessage {
+    class ServerResponse<Request extends IncomingMessage = IncomingMessage> extends OutgoingMessage<Request> {
         /**
          * When using implicit headers (not calling `response.writeHead()` explicitly),
          * this property controls the status code that will be sent to the client when
@@ -491,7 +557,7 @@ declare module 'http' {
          * @since v0.11.8
          */
         statusMessage: string;
-        constructor(req: IncomingMessage);
+        constructor(req: Request);
         assignSocket(socket: Socket): void;
         detachSocket(socket: Socket): void;
         /**
@@ -557,7 +623,11 @@ declare module 'http' {
          * will result in a `TypeError` being thrown.
          * @since v0.1.30
          */
-        writeHead(statusCode: number, statusMessage?: string, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): this;
+        writeHead(
+            statusCode: number,
+            statusMessage?: string,
+            headers?: OutgoingHttpHeaders | OutgoingHttpHeader[],
+        ): this;
         writeHead(statusCode: number, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): this;
         /**
          * Sends a HTTP/1.1 102 Processing message to the client, indicating that
@@ -681,13 +751,19 @@ declare module 'http' {
          */
         getRawHeaderNames(): string[];
         addListener(event: 'abort', listener: () => void): this;
-        addListener(event: 'connect', listener: (response: IncomingMessage, socket: Socket, head: Buffer) => 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: '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;
@@ -726,13 +802,19 @@ declare module 'http' {
         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: '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: '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;
@@ -741,13 +823,19 @@ declare module 'http' {
         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: '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: '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;
@@ -1114,8 +1202,14 @@ declare module 'http' {
      * added to the `'request'` event.
      * @since v0.1.13
      */
-    function createServer(requestListener?: RequestListener): Server;
-    function createServer(options: ServerOptions, requestListener?: RequestListener): Server;
+    function createServer<
+        Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Response extends typeof ServerResponse = typeof ServerResponse,
+    >(requestListener?: RequestListener<Request, Response>): Server<Request, Response>;
+    function createServer<
+        Request extends typeof IncomingMessage = typeof IncomingMessage,
+        Response extends typeof ServerResponse = typeof ServerResponse,
+    >(options: ServerOptions, requestListener?: RequestListener<Request, Response>): Server<Request, Response>;
     // although RequestOptions are passed as ClientRequestArgs to ClientRequest directly,
     // create interface RequestOptions would make the naming more clear to developers
     interface RequestOptions extends ClientRequestArgs {}
@@ -1304,7 +1398,11 @@ declare module 'http' {
      * @since v0.3.6
      */
     function request(options: RequestOptions | string | URL, callback?: (res: IncomingMessage) => void): ClientRequest;
-    function request(url: string | URL, options: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest;
+    function request(
+        url: string | URL,
+        options: RequestOptions,
+        callback?: (res: IncomingMessage) => void,
+    ): ClientRequest;
     /**
      * Since most requests are GET requests without bodies, Node.js provides this
      * convenience method. The only difference between this method and {@link request} is that it sets the method to GET and calls `req.end()`automatically. The callback must take care to consume the

node v16.11/http2.d.ts

@@ -780,7 +780,7 @@ declare module 'http2' {
          * @since v8.4.0
          * @param callback Callback that is called once the session is connected or right away if the session is already connected.
          */
-        settings(settings: Settings): void;
+        settings(settings: Settings, callback?: (err: Error | null, settings: Settings, duration: number) => void): void;
         /**
          * Calls `unref()` on this `Http2Session`instance's underlying `net.Socket`.
          * @since v9.4.0

node v16.11/https.d.ts

@@ -8,7 +8,10 @@ declare module 'https' {
     import * as tls from 'node:tls';
     import * as http from 'node:http';
     import { URL } from 'node:url';
-    type ServerOptions = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions;
+    type ServerOptions<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    > = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions<Request, Response>;
     type RequestOptions = http.RequestOptions &
         tls.SecureContextOptions & {
             rejectUnauthorized?: boolean | undefined; // Defaults to true
@@ -26,35 +29,73 @@ declare module 'https' {
         constructor(options?: AgentOptions);
         options: AgentOptions;
     }
-    interface Server extends http.Server {}
+    interface Server<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    > extends http.Server<Request, Response> {}
     /**
      * See `http.Server` for more information.
      * @since v0.3.4
      */
-    class Server extends tls.Server {
-        constructor(requestListener?: http.RequestListener);
-        constructor(options: ServerOptions, requestListener?: http.RequestListener);
+    class Server<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    > extends tls.Server {
+        constructor(requestListener?: http.RequestListener<Request, Response>);
+        constructor(
+            options: ServerOptions<Request, Response>,
+            requestListener?: http.RequestListener<Request, Response>,
+        );
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        addListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        addListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        addListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        addListener(
+            event: 'newSession',
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+        ): this;
+        addListener(
+            event: 'OCSPRequest',
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        addListener(
+            event: 'resumeSession',
+            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+        ): this;
         addListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         addListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         addListener(event: 'close', listener: () => void): this;
         addListener(event: 'connection', listener: (socket: Duplex) => void): this;
         addListener(event: 'error', listener: (err: Error) => void): this;
         addListener(event: 'listening', listener: () => void): this;
-        addListener(event: 'checkContinue', listener: http.RequestListener): this;
-        addListener(event: 'checkExpectation', listener: http.RequestListener): this;
+        addListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        addListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         addListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        addListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        addListener(event: 'request', listener: http.RequestListener): this;
-        addListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        addListener(
+            event: 'connect',
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
+        addListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        addListener(
+            event: 'upgrade',
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
         emit(event: string, ...args: any[]): boolean;
         emit(event: 'keylog', line: Buffer, tlsSocket: tls.TLSSocket): boolean;
-        emit(event: 'newSession', sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void): boolean;
-        emit(event: 'OCSPRequest', certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void): boolean;
+        emit(
+            event: 'newSession',
+            sessionId: Buffer,
+            sessionData: Buffer,
+            callback: (err: Error, resp: Buffer) => void,
+        ): boolean;
+        emit(
+            event: 'OCSPRequest',
+            certificate: Buffer,
+            issuer: Buffer,
+            callback: (err: Error | null, resp: Buffer) => void,
+        ): boolean;
         emit(event: 'resumeSession', sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void): boolean;
         emit(event: 'secureConnection', tlsSocket: tls.TLSSocket): boolean;
         emit(event: 'tlsClientError', err: Error, tlsSocket: tls.TLSSocket): boolean;
@@ -62,80 +103,156 @@ declare module 'https' {
         emit(event: 'connection', socket: Duplex): boolean;
         emit(event: 'error', err: Error): boolean;
         emit(event: 'listening'): boolean;
-        emit(event: 'checkContinue', req: http.IncomingMessage, res: http.ServerResponse): boolean;
-        emit(event: 'checkExpectation', req: http.IncomingMessage, res: http.ServerResponse): boolean;
+        emit(
+            event: 'checkContinue',
+            req: InstanceType<Request>,
+            res: InstanceType<Response> & { req: InstanceType<Request> },
+        ): boolean;
+        emit(
+            event: 'checkExpectation',
+            req: InstanceType<Request>,
+            res: InstanceType<Response> & { req: InstanceType<Request> },
+        ): boolean;
         emit(event: 'clientError', err: Error, socket: Duplex): boolean;
-        emit(event: 'connect', req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
-        emit(event: 'request', req: http.IncomingMessage, res: http.ServerResponse): boolean;
-        emit(event: 'upgrade', req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
+        emit(event: 'connect', req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
+        emit(
+            event: 'request',
+            req: InstanceType<Request>,
+            res: InstanceType<Response> & { req: InstanceType<Request> },
+        ): boolean;
+        emit(event: 'upgrade', req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        on(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        on(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        on(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        on(
+            event: 'newSession',
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+        ): this;
+        on(
+            event: 'OCSPRequest',
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        on(
+            event: 'resumeSession',
+            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+        ): this;
         on(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         on(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         on(event: 'close', listener: () => void): this;
         on(event: 'connection', listener: (socket: Duplex) => void): this;
         on(event: 'error', listener: (err: Error) => void): this;
         on(event: 'listening', listener: () => void): this;
-        on(event: 'checkContinue', listener: http.RequestListener): this;
-        on(event: 'checkExpectation', listener: http.RequestListener): this;
+        on(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        on(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         on(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        on(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        on(event: 'request', listener: http.RequestListener): this;
-        on(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        on(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        on(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        on(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        once(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        once(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        once(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        once(
+            event: 'newSession',
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+        ): this;
+        once(
+            event: 'OCSPRequest',
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        once(
+            event: 'resumeSession',
+            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+        ): this;
         once(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         once(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         once(event: 'close', listener: () => void): this;
         once(event: 'connection', listener: (socket: Duplex) => void): this;
         once(event: 'error', listener: (err: Error) => void): this;
         once(event: 'listening', listener: () => void): this;
-        once(event: 'checkContinue', listener: http.RequestListener): this;
-        once(event: 'checkExpectation', listener: http.RequestListener): this;
+        once(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        once(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         once(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        once(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        once(event: 'request', listener: http.RequestListener): this;
-        once(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        once(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        once(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        once(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        prependListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        prependListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        prependListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        prependListener(
+            event: 'newSession',
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+        ): this;
+        prependListener(
+            event: 'OCSPRequest',
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        prependListener(
+            event: 'resumeSession',
+            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+        ): this;
         prependListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         prependListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         prependListener(event: 'close', listener: () => void): this;
         prependListener(event: 'connection', listener: (socket: Duplex) => void): this;
         prependListener(event: 'error', listener: (err: Error) => void): this;
         prependListener(event: 'listening', listener: () => void): this;
-        prependListener(event: 'checkContinue', listener: http.RequestListener): this;
-        prependListener(event: 'checkExpectation', listener: http.RequestListener): this;
+        prependListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        prependListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         prependListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        prependListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        prependListener(event: 'request', listener: http.RequestListener): this;
-        prependListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        prependListener(
+            event: 'connect',
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
+        prependListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        prependListener(
+            event: 'upgrade',
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        prependOnceListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        prependOnceListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        prependOnceListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        prependOnceListener(
+            event: 'newSession',
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+        ): this;
+        prependOnceListener(
+            event: 'OCSPRequest',
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        prependOnceListener(
+            event: 'resumeSession',
+            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+        ): this;
         prependOnceListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         prependOnceListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         prependOnceListener(event: 'close', listener: () => void): this;
         prependOnceListener(event: 'connection', listener: (socket: Duplex) => void): this;
         prependOnceListener(event: 'error', listener: (err: Error) => void): this;
         prependOnceListener(event: 'listening', listener: () => void): this;
-        prependOnceListener(event: 'checkContinue', listener: http.RequestListener): this;
-        prependOnceListener(event: 'checkExpectation', listener: http.RequestListener): this;
+        prependOnceListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        prependOnceListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         prependOnceListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        prependOnceListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        prependOnceListener(event: 'request', listener: http.RequestListener): this;
-        prependOnceListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        prependOnceListener(
+            event: 'connect',
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
+        prependOnceListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        prependOnceListener(
+            event: 'upgrade',
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
     }
     /**
      * ```js
@@ -174,8 +291,17 @@ declare module 'https' {
      * @param options Accepts `options` from `createServer`, `createSecureContext` and `createServer`.
      * @param requestListener A listener to be added to the `'request'` event.
      */
-    function createServer(requestListener?: http.RequestListener): Server;
-    function createServer(options: ServerOptions, requestListener?: http.RequestListener): Server;
+    function createServer<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    >(requestListener?: http.RequestListener<Request, Response>): Server<Request, Response>;
+    function createServer<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    >(
+        options: ServerOptions<Request, Response>,
+        requestListener?: http.RequestListener<Request, Response>,
+    ): Server<Request, Response>;
     /**
      * Makes a request to a secure web server.
      *
@@ -356,8 +482,15 @@ declare module 'https' {
      * @since v0.3.6
      * @param options Accepts all `options` from `request`, with some differences in default values:
      */
-    function request(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
-    function request(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function request(
+        options: RequestOptions | string | URL,
+        callback?: (res: http.IncomingMessage) => void,
+    ): http.ClientRequest;
+    function request(
+        url: string | URL,
+        options: RequestOptions,
+        callback?: (res: http.IncomingMessage) => void,
+    ): http.ClientRequest;
     /**
      * Like `http.get()` but for HTTPS.
      *
@@ -382,8 +515,15 @@ declare module 'https' {
      * @since v0.3.6
      * @param options Accepts the same `options` as {@link request}, with the `method` always set to `GET`.
      */
-    function get(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
-    function get(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function get(
+        options: RequestOptions | string | URL,
+        callback?: (res: http.IncomingMessage) => void,
+    ): http.ClientRequest;
+    function get(
+        url: string | URL,
+        options: RequestOptions,
+        callback?: (res: http.IncomingMessage) => void,
+    ): http.ClientRequest;
     let globalAgent: Agent;
 }
 declare module 'node:https' {

node v16.11/net.d.ts

@@ -54,6 +54,9 @@ declare module 'net' {
         hints?: number | undefined;
         family?: number | undefined;
         lookup?: LookupFunction | undefined;
+        noDelay?: boolean | undefined;
+        keepAlive?: boolean | undefined;
+        keepAliveInitialDelay?: number | undefined;
     }
     interface IpcSocketConnectOpts extends ConnectOpts {
         path: string;
@@ -399,6 +402,25 @@ declare module 'net' {
          * @default false
          */
         pauseOnConnect?: boolean | undefined;
+        /**
+         * If set to `true`, it disables the use of Nagle's algorithm immediately after a new incoming connection is received.
+         * @default false
+         * @since v16.5.0
+         */
+        noDelay?: boolean | undefined;
+        /**
+         * If set to `true`, it enables keep-alive functionality on the socket immediately after a new incoming connection is received,
+         * similarly on what is done in `socket.setKeepAlive([enable][, initialDelay])`.
+         * @default false
+         * @since v16.5.0
+         */
+        keepAlive?: boolean | undefined;
+        /**
+         * If set to a positive number, it sets the initial delay before the first keepalive probe is sent on an idle socket.
+         * @default 0
+         * @since v16.5.0
+         */
+        keepAliveInitialDelay?: number | undefined;
     }
     /**
      * This class is used to create a TCP or `IPC` server.

node v16.11/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "16.11.55",
+    "version": "16.11.58",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -220,6 +220,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "34fd4a12bcb0e6691bcda03a9b043e62af3bd45fdb632f098b72433cd011731b",
-    "typeScriptVersion": "4.0"
+    "typesPublisherContentHash": "be106dd067eddfded19382dbba47c191f861c92840693ae27bddb20bc1fe359a",
+    "typeScriptVersion": "4.1"
 }