@types/node 16.4.11 → 16.6.0

node/dgram.d.ts

@@ -2,7 +2,8 @@
  * The `dgram` module provides an implementation of UDP datagram sockets.
  *
  * ```js
- * const dgram = require('dgram');
+ * import dgram from 'dgram';
+ *
  * const server = dgram.createSocket('udp4');
  *
  * server.on('error', (err) => {
@@ -22,7 +23,7 @@
  * server.bind(41234);
  * // Prints: server listening 0.0.0.0:41234
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/dgram.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.6.0/lib/dgram.js)
  */
 declare module 'dgram' {
     import { AddressInfo } from 'node:net';
@@ -97,8 +98,9 @@ declare module 'dgram' {
          * When sharing a UDP socket across multiple `cluster` workers, the`socket.addMembership()` function must be called only once or an`EADDRINUSE` error will occur:
          *
          * ```js
-         * const cluster = require('cluster');
-         * const dgram = require('dgram');
+         * import cluster from 'cluster';
+         * import dgram from 'dgram';
+         *
          * if (cluster.isPrimary) {
          *   cluster.fork(); // Works ok.
          *   cluster.fork(); // Fails with EADDRINUSE.
@@ -140,7 +142,8 @@ declare module 'dgram' {
          * Example of a UDP server listening on port 41234:
          *
          * ```js
-         * const dgram = require('dgram');
+         * import dgram from 'dgram';
+         *
          * const server = dgram.createSocket('udp4');
          *
          * server.on('error', (err) => {
@@ -281,7 +284,9 @@ declare module 'dgram' {
          * Example of sending a UDP packet to a port on `localhost`;
          *
          * ```js
-         * const dgram = require('dgram');
+         * import dgram from 'dgram';
+         * import { Buffer } from 'buffer';
+         *
          * const message = Buffer.from('Some bytes');
          * const client = dgram.createSocket('udp4');
          * client.send(message, 41234, 'localhost', (err) => {
@@ -292,7 +297,9 @@ declare module 'dgram' {
          * Example of sending a UDP packet composed of multiple buffers to a port on`127.0.0.1`;
          *
          * ```js
-         * const dgram = require('dgram');
+         * import dgram from 'dgram';
+         * import { Buffer } from 'buffer';
+         *
          * const buf1 = Buffer.from('Some ');
          * const buf2 = Buffer.from('bytes');
          * const client = dgram.createSocket('udp4');
@@ -309,7 +316,9 @@ declare module 'dgram' {
          * Example of sending a UDP packet using a socket connected to a port on`localhost`:
          *
          * ```js
-         * const dgram = require('dgram');
+         * import dgram from 'dgram';
+         * import { Buffer } from 'buffer';
+         *
          * const message = Buffer.from('Some bytes');
          * const client = dgram.createSocket('udp4');
          * client.connect(41234, 'localhost', (err) => {

node/diagnostics_channel.d.ts

@@ -5,7 +5,7 @@
  * It can be accessed using:
  *
  * ```js
- * const diagnostics_channel = require('diagnostics_channel');
+ * import diagnostics_channel from 'diagnostics_channel';
  * ```
  *
  * It is intended that a module writer wanting to report diagnostics messages
@@ -20,7 +20,7 @@
  * should generally include the module name to avoid collisions with data from
  * other modules.
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/diagnostics_channel.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.6.0/lib/diagnostics_channel.js)
  */
 declare module 'diagnostics_channel' {
     /**
@@ -31,7 +31,7 @@ declare module 'diagnostics_channel' {
      * performance-sensitive code.
      *
      * ```js
-     * const diagnostics_channel = require('diagnostics_channel');
+     * import diagnostics_channel from 'diagnostics_channel';
      *
      * if (diagnostics_channel.hasSubscribers('my-channel')) {
      *   // There are subscribers, prepare and publish message
@@ -47,7 +47,7 @@ declare module 'diagnostics_channel' {
      * publish time as much as possible.
      *
      * ```js
-     * const diagnostics_channel = require('diagnostics_channel');
+     * import diagnostics_channel from 'diagnostics_channel';
      *
      * const channel = diagnostics_channel.channel('my-channel');
      * ```
@@ -66,7 +66,24 @@ declare module 'diagnostics_channel' {
      */
     class Channel {
         readonly name: string;
-        readonly hashSubscribers: boolean;
+        /**
+         * Check if there are active subscribers to this channel. This is helpful if
+         * the message you want to send might be expensive to prepare.
+         *
+         * This API is optional but helpful when trying to publish messages from very
+         * performance-sensitive code.
+         *
+         * ```js
+         * import diagnostics_channel from 'diagnostics_channel';
+         *
+         * const channel = diagnostics_channel.channel('my-channel');
+         *
+         * if (channel.hasSubscribers) {
+         *   // There are subscribers, prepare and publish message
+         * }
+         * ```
+         */
+        readonly hasSubscribers: boolean;
         private constructor(name: string);
         /**
          * Register a message handler to subscribe to this channel. This message handler
@@ -74,7 +91,7 @@ declare module 'diagnostics_channel' {
          * errors thrown in the message handler will trigger an `'uncaughtException'`.
          *
          * ```js
-         * const diagnostics_channel = require('diagnostics_channel');
+         * import diagnostics_channel from 'diagnostics_channel';
          *
          * const channel = diagnostics_channel.channel('my-channel');
          *
@@ -89,7 +106,7 @@ declare module 'diagnostics_channel' {
          * Remove a message handler previously registered to this channel with `channel.subscribe(onMessage)`.
          *
          * ```js
-         * const diagnostics_channel = require('diagnostics_channel');
+         * import diagnostics_channel from 'diagnostics_channel';
          *
          * const channel = diagnostics_channel.channel('my-channel');
          *

node/dns.d.ts

@@ -42,7 +42,7 @@
  * ```
  *
  * See the `Implementation considerations section` for more information.
- * @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/dns.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.6.0/lib/dns.js)
  */
 declare module 'dns' {
     import * as dnsPromises from 'node:dns/promises';

node/domain.d.ts

@@ -1,5 +1,5 @@
 /**
- * **This module is pending deprecation**. Once a replacement API has been
+ * **This module is pending deprecation.** Once a replacement API has been
  * finalized, this module will be fully deprecated. Most developers should**not** have cause to use this module. Users who absolutely must have
  * the functionality that domains provide may rely on it for the time being
  * but should expect to have to migrate to a different solution
@@ -11,7 +11,7 @@
  * will be notified, rather than losing the context of the error in the`process.on('uncaughtException')` handler, or causing the program to
  * exit immediately with an error code.
  * @deprecated Since v1.4.2 - Deprecated
- * @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/domain.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.6.0/lib/domain.js)
  */
 declare module 'domain' {
     import EventEmitter = require('node:events');

node/events.d.ts

@@ -32,7 +32,7 @@
  * });
  * myEmitter.emit('event');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/events.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.6.0/lib/events.js)
  */
 declare module 'events' {
     interface EventEmitterOptions {

node/fs/promises.d.ts

@@ -29,7 +29,12 @@ declare module 'fs/promises' {
         OpenMode,
         Mode,
         WatchOptions,
+        WatchEventType,
     } from 'node:fs';
+    interface FileChangeInfo<T extends (string | Buffer)> {
+        eventType: WatchEventType;
+        filename: T;
+    }
     interface FlagAndOpenMode {
         mode?: Mode | undefined;
         flag?: OpenMode | undefined;
@@ -233,6 +238,8 @@ declare module 'fs/promises' {
         /**
          * Write `buffer` to the file.
          *
+         * If `buffer` is a plain object, it must have an own (not inherited) `toString`function property.
+         *
          * The promise is resolved with an object containing two properties:
          *
          * It is unsafe to use `filehandle.write()` multiple times on the same file
@@ -732,8 +739,7 @@ declare module 'fs/promises' {
      */
     function mkdtemp(prefix: string, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string | Buffer>;
     /**
-     * Asynchronously writes data to a file, replacing the file if it already exists.`data` can be a string, a `<Buffer>`, or an object with an own `toString` function
-     * property.
+     * Asynchronously writes data to a file, replacing the file if it already exists.`data` can be a string, a `<Buffer>`, or, an object with an own (not inherited)`toString` function property.
      *
      * The `encoding` option is ignored if `data` is a buffer.
      *
@@ -754,6 +760,7 @@ declare module 'fs/promises' {
      *
      * ```js
      * import { writeFile } from 'fs/promises';
+     * import { Buffer } from 'buffer';
      *
      * try {
      *   const controller = new AbortController();
@@ -951,7 +958,7 @@ declare module 'fs/promises' {
                   encoding: 'buffer';
               })
             | 'buffer'
-    ): AsyncIterable<Buffer>;
+    ): AsyncIterable<FileChangeInfo<Buffer>>;
     /**
      * Watch for changes on `filename`, where `filename` is either a file or a directory, returning an `FSWatcher`.
      * @param filename A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
@@ -960,7 +967,7 @@ declare module 'fs/promises' {
      * If `persistent` is not supplied, the default of `true` is used.
      * If `recursive` is not supplied, the default of `false` is used.
      */
-    function watch(filename: PathLike, options?: WatchOptions | BufferEncoding): AsyncIterable<string>;
+    function watch(filename: PathLike, options?: WatchOptions | BufferEncoding): AsyncIterable<FileChangeInfo<string>>;
     /**
      * Watch for changes on `filename`, where `filename` is either a file or a directory, returning an `FSWatcher`.
      * @param filename A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
@@ -969,7 +976,7 @@ declare module 'fs/promises' {
      * If `persistent` is not supplied, the default of `true` is used.
      * If `recursive` is not supplied, the default of `false` is used.
      */
-    function watch(filename: PathLike, options: WatchOptions | string): AsyncIterable<string> | AsyncIterable<Buffer>;
+    function watch(filename: PathLike, options: WatchOptions | string): AsyncIterable<FileChangeInfo<string>> | AsyncIterable<FileChangeInfo<Buffer>>;
 }
 declare module 'node:fs/promises' {
     export * from 'fs/promises';

node/fs.d.ts

@@ -5,30 +5,18 @@
  * To use the promise-based APIs:
  *
  * ```js
- * // Using ESM Module syntax:
  * import * as fs from 'fs/promises';
  * ```
  *
- * ```js
- * // Using CommonJS syntax:
- * const fs = require('fs/promises');
- * ```
- *
  * To use the callback and sync APIs:
  *
  * ```js
- * // Using ESM Module syntax:
  * import * as fs from 'fs';
  * ```
  *
- * ```js
- * // Using CommonJS syntax:
- * const fs = require('fs');
- * ```
- *
  * All file system operations have synchronous, callback, and promise-based
  * forms, and are accessible using both CommonJS syntax and ES6 Modules (ESM).
- * @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/fs.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.6.0/lib/fs.js)
  */
 declare module 'fs' {
     import * as stream from 'node:stream';
@@ -2177,6 +2165,8 @@ declare module 'fs' {
         }>;
     }
     /**
+     * If `buffer` is a plain object, it must have an own (not inherited) `toString`function property.
+     *
      * For detailed information, see the documentation of the asynchronous version of
      * this API: {@link write}.
      * @since v0.1.21
@@ -2510,10 +2500,12 @@ declare module 'fs' {
      * a file descriptor.
      *
      * The `encoding` option is ignored if `data` is a buffer.
-     * If `data` is a normal object, it must have an own `toString` function property.
+     *
+     * If `data` is a plain object, it must have an own (not inherited) `toString`function property.
      *
      * ```js
      * import { writeFile } from 'fs';
+     * import { Buffer } from 'buffer';
      *
      * const data = new Uint8Array(Buffer.from('Hello Node.js'));
      * writeFile('message.txt', data, (err) => {
@@ -2544,6 +2536,7 @@ declare module 'fs' {
      *
      * ```js
      * import { writeFile } from 'fs';
+     * import { Buffer } from 'buffer';
      *
      * const controller = new AbortController();
      * const { signal } = controller;
@@ -2586,6 +2579,8 @@ declare module 'fs' {
     /**
      * Returns `undefined`.
      *
+     * If `data` is a plain object, it must have an own (not inherited) `toString`function property.
+     *
      * For detailed information, see the documentation of the asynchronous version of
      * this API: {@link writeFile}.
      * @since v0.1.29
@@ -2791,7 +2786,8 @@ declare module 'fs' {
         persistent?: boolean | undefined;
         recursive?: boolean | undefined;
     }
-    export type WatchListener<T> = (event: 'rename' | 'change', filename: T) => void;
+    export type WatchEventType = 'rename' | 'change';
+    export type WatchListener<T> = (event: WatchEventType, filename: T) => void;
     /**
      * Watch for changes on `filename`, where `filename` is either a file or a
      * directory.
@@ -3145,7 +3141,7 @@ declare module 'fs' {
      * });
      *
      * // Check if the file exists in the current directory, and if it is writable.
-     * access(file, constants.F_OK | fs.constants.W_OK, (err) => {
+     * access(file, constants.F_OK | constants.W_OK, (err) => {
      *   if (err) {
      *     console.error(
      *       `${file} ${err.code === 'ENOENT' ? 'does not exist' : 'is read-only'}`);

node/globals.d.ts

@@ -13,19 +13,6 @@ interface ErrorConstructor {
     stackTraceLimit: number;
 }
 
-// Node.js ESNEXT support
-interface String {
-    /** Removes whitespace from the left end of a string. */
-    trimLeft(): string;
-    /** Removes whitespace from the right end of a string. */
-    trimRight(): string;
-
-    /** Returns a copy with leading whitespace removed. */
-    trimStart(): string;
-    /** Returns a copy with trailing whitespace removed. */
-    trimEnd(): string;
-}
-
 /*-----------------------------------------------*
  *                                               *
  *                   GLOBAL                      *
@@ -89,6 +76,30 @@ declare var AbortSignal: {
 };
 //#endregion borrowed
 
+//#region ArrayLike.at()
+interface RelativeIndexable<T> {
+    /**
+     * Takes an integer value and returns the item at that index,
+     * allowing for positive and negative integers.
+     * Negative integers count back from the last item in the array.
+     */
+    at(index: number): T | undefined;
+}
+interface String extends RelativeIndexable<string> {}
+interface Array<T> extends RelativeIndexable<T> {}
+interface Int8Array extends RelativeIndexable<number> {}
+interface Uint8Array extends RelativeIndexable<number> {}
+interface Uint8ClampedArray extends RelativeIndexable<number> {}
+interface Int16Array extends RelativeIndexable<number> {}
+interface Uint16Array extends RelativeIndexable<number> {}
+interface Int32Array extends RelativeIndexable<number> {}
+interface Uint32Array extends RelativeIndexable<number> {}
+interface Float32Array extends RelativeIndexable<number> {}
+interface Float64Array extends RelativeIndexable<number> {}
+interface BigInt64Array extends RelativeIndexable<bigint> {}
+interface BigUint64Array extends RelativeIndexable<bigint> {}
+//#endregion ArrayLike.at() end
+
 /*----------------------------------------------*
 *                                               *
 *               GLOBAL INTERFACES               *

node/http.d.ts

@@ -37,7 +37,7 @@
  *   'Host', 'mysite.com',
  *   'accepT', '*' ]
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/http.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.6.0/lib/http.js)
  */
 declare module 'http' {
     import * as stream from 'node:stream';
@@ -156,37 +156,154 @@ declare module 'http' {
         insecureHTTPParser?: boolean | undefined;
     }
     type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
-    interface HttpBase {
+    /**
+     * @since v0.1.17
+     */
+    class Server extends NetServer {
+        constructor(requestListener?: RequestListener);
+        constructor(options: ServerOptions, requestListener?: RequestListener);
+        /**
+         * Sets the timeout value for sockets, and emits a `'timeout'` event on
+         * the Server object, passing the socket as an argument, if a timeout
+         * occurs.
+         *
+         * If there is a `'timeout'` event listener on the Server object, then it
+         * will be called with the timed-out socket as an argument.
+         *
+         * By default, the Server does not timeout sockets. However, if a callback
+         * is assigned to the Server's `'timeout'` event, timeouts must be handled
+         * explicitly.
+         * @since v0.9.12
+         * @param [msecs=0 (no timeout)]
+         */
         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}
+         * @since v0.7.0
          */
         maxHeadersCount: number | null;
+        /**
+         * The number of milliseconds of inactivity before a socket is presumed
+         * to have timed out.
+         *
+         * A value of `0` will disable the timeout behavior on incoming connections.
+         *
+         * The socket timeout logic is set up on connection, so changing this
+         * value only affects new connections to the server, not any existing connections.
+         * @since v0.9.12
+         */
         timeout: number;
         /**
-         * Limit the amount of time the parser will wait to receive the complete HTTP headers.
-         * @default 60000
-         * {@link https://nodejs.org/api/http.html#http_server_headerstimeout}
+         * Limit the amount of time the parser will wait to receive the complete HTTP
+         * headers.
+         *
+         * In case of inactivity, the rules defined in `server.timeout` apply. However,
+         * that inactivity based timeout would still allow the connection to be kept open
+         * if the headers are being sent very slowly (by default, up to a byte per 2
+         * minutes). In order to prevent this, whenever header data arrives an additional
+         * check is made that more than `server.headersTimeout` milliseconds has not
+         * passed since the connection was established. If the check fails, a `'timeout'`event is emitted on the server object, and (by default) the socket is destroyed.
+         * See `server.timeout` for more information on how timeout behavior can be
+         * customized.
+         * @since v11.3.0, v10.14.0
          */
         headersTimeout: number;
+        /**
+         * The number of milliseconds of inactivity a server needs to wait for additional
+         * incoming data, after it has finished writing the last response, before a socket
+         * will be destroyed. If the server receives new data before the keep-alive
+         * timeout has fired, it will reset the regular inactivity timeout, i.e.,`server.timeout`.
+         *
+         * A value of `0` will disable the keep-alive timeout behavior on incoming
+         * connections.
+         * A value of `0` makes the http server behave similarly to Node.js versions prior
+         * to 8.0.0, which did not have a keep-alive timeout.
+         *
+         * The socket timeout logic is set up on connection, so changing this value only
+         * affects new connections to the server, not any existing connections.
+         * @since v8.0.0
+         */
         keepAliveTimeout: number;
         /**
-         * Sets the timeout value in milliseconds for receiving the entire request from the client.
-         * @default 0
-         * {@link https://nodejs.org/api/http.html#http_server_requesttimeout}
+         * Sets the timeout value in milliseconds for receiving the entire request from
+         * the client.
+         *
+         * If the timeout expires, the server responds with status 408 without
+         * forwarding the request to the request listener and then closes the connection.
+         *
+         * It must be set to a non-zero value (e.g. 120 seconds) to protect against
+         * potential Denial-of-Service attacks in case the server is deployed without a
+         * reverse proxy in front.
+         * @since v14.11.0
          */
         requestTimeout: number;
-    }
-    interface Server extends HttpBase {}
-    /**
-     * @since v0.1.17
-     */
-    class Server extends NetServer {
-        constructor(requestListener?: RequestListener);
-        constructor(options: ServerOptions, requestListener?: RequestListener);
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: 'close', listener: () => void): this;
+        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: '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;
+        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: '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;
+        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: '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;
+        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: '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;
+        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: '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;
+        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: '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;
     }
     /**
      * This class serves as the parent class of {@link ClientRequest} and {@link ServerResponse}. It is an abstract of outgoing message from

node/http2.d.ts

@@ -6,7 +6,7 @@
  * const http2 = require('http2');
  * ```
  * @since v8.4.0
- * @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/http2.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.6.0/lib/http2.js)
  */
 declare module 'http2' {
     import EventEmitter = require('node:events');