@types/node 20.0.0 → 20.1.0

node/ts4.8/globals.d.ts

@@ -45,42 +45,42 @@ declare var gc: undefined | (() => void);
 // from https://github.com/microsoft/TypeScript/blob/38da7c600c83e7b31193a62495239a0fe478cb67/lib/lib.webworker.d.ts#L633 until moved to separate lib
 /** A controller object that allows you to abort one or more DOM requests as and when desired. */
 interface AbortController {
-  /**
-   * Returns the AbortSignal object associated with this object.
-   */
-
-  readonly signal: AbortSignal;
-  /**
-   * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
-   */
-  abort(reason?: any): void;
+    /**
+     * Returns the AbortSignal object associated with this object.
+     */
+
+    readonly signal: AbortSignal;
+    /**
+     * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
+     */
+    abort(reason?: any): void;
 }
 
 /** A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. */
 interface AbortSignal extends EventTarget {
-  /**
-   * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
-   */
-  readonly aborted: boolean;
-  readonly reason: any;
-  onabort: null | ((this: AbortSignal, event: Event) => any);
+    /**
+     * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
+     */
+    readonly aborted: boolean;
+    readonly reason: any;
+    onabort: null | ((this: AbortSignal, event: Event) => any);
 }
 
 declare var AbortController: typeof globalThis extends {onmessage: any; AbortController: infer T}
-  ? T
-  : {
-      prototype: AbortController;
-      new(): AbortController;
-  };
+    ? T
+    : {
+        prototype: AbortController;
+        new(): AbortController;
+    };
 
 declare var AbortSignal: typeof globalThis extends {onmessage: any; AbortSignal: infer T}
-  ? T
-  : {
-      prototype: AbortSignal;
-      new(): AbortSignal;
-      abort(reason?: any): AbortSignal;
-      timeout(milliseconds: number): AbortSignal;
-  };
+    ? T
+    : {
+        prototype: AbortSignal;
+        new(): AbortSignal;
+        abort(reason?: any): AbortSignal;
+        timeout(milliseconds: number): AbortSignal;
+    };
 //#endregion borrowed
 
 //#region ArrayLike.at()
@@ -94,6 +94,7 @@ interface RelativeIndexable<T> {
 }
 interface String extends RelativeIndexable<string> {}
 interface Array<T> extends RelativeIndexable<T> {}
+interface ReadonlyArray<T> extends RelativeIndexable<T> {}
 interface Int8Array extends RelativeIndexable<number> {}
 interface Uint8Array extends RelativeIndexable<number> {}
 interface Uint8ClampedArray extends RelativeIndexable<number> {}
@@ -158,7 +159,7 @@ declare namespace NodeJS {
         /**
          * Name of the script [if this function was defined in a script]
          */
-        getFileName(): string | null;
+        getFileName(): string | undefined;
 
         /**
          * Current line number [if this function was defined in a script]

node/ts4.8/http.d.ts

@@ -37,7 +37,7 @@
  *   'Host', 'example.com',
  *   'accepT', '*' ]
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.0.0/lib/http.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/http.js)
  */
 declare module 'http' {
     import * as stream from 'node:stream';
@@ -144,6 +144,7 @@ declare module 'http' {
         socketPath?: string | undefined;
         timeout?: number | undefined;
         uniqueHeaders?: Array<string | string[]> | undefined;
+        joinDuplicateHeaders?: boolean;
     }
     interface ServerOptions<
         Request extends typeof IncomingMessage = typeof IncomingMessage,
@@ -164,6 +165,12 @@ declare module 'http' {
          * @since v18.0.0
          */
         requestTimeout?: number | undefined;
+        /**
+         * It joins the field line values of multiple headers in a request with `, ` instead of discarding the duplicates.
+         * @default false
+         * @since v18.14.0
+         */
+        joinDuplicateHeaders?: boolean;
         /**
          * 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.
@@ -177,6 +184,13 @@ declare module 'http' {
          * @default 30000
          */
         connectionsCheckingInterval?: number | undefined;
+        /**
+         * Optionally overrides all `socket`s' `readableHighWaterMark` and `writableHighWaterMark`.
+         * This affects `highWaterMark` property of both `IncomingMessage` and `ServerResponse`.
+         * Default: @see stream.getDefaultHighWaterMark().
+         * @since v20.1.0
+         */
+        highWaterMark?: number | undefined;
         /**
          * Use an insecure HTTP parser that accepts invalid HTTP headers when `true`.
          * Using the insecure parser should be avoided.
@@ -336,6 +350,7 @@ declare module 'http' {
         addListener(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         addListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
         addListener(event: 'connect', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
+        addListener(event: 'dropRequest', listener: (req: InstanceType<Request>, socket: stream.Duplex) => 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;
@@ -355,6 +370,7 @@ declare module 'http' {
         ): boolean;
         emit(event: 'clientError', err: Error, socket: stream.Duplex): boolean;
         emit(event: 'connect', req: InstanceType<Request>, socket: stream.Duplex, head: Buffer): boolean;
+        emit(event: 'dropRequest', req: InstanceType<Request>, socket: stream.Duplex): boolean;
         emit(
             event: 'request',
             req: InstanceType<Request>,
@@ -370,6 +386,7 @@ declare module 'http' {
         on(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         on(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
         on(event: 'connect', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
+        on(event: 'dropRequest', listener: (req: InstanceType<Request>, socket: stream.Duplex) => 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;
@@ -381,6 +398,7 @@ declare module 'http' {
         once(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         once(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
         once(event: 'connect', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
+        once(event: 'dropRequest', listener: (req: InstanceType<Request>, socket: stream.Duplex) => 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;
@@ -392,6 +410,7 @@ declare module 'http' {
         prependListener(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         prependListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
         prependListener(event: 'connect', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
+        prependListener(event: 'dropRequest', listener: (req: InstanceType<Request>, socket: stream.Duplex) => 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;
@@ -403,6 +422,7 @@ declare module 'http' {
         prependOnceListener(event: 'checkExpectation', listener: RequestListener<Request, Response>): this;
         prependOnceListener(event: 'clientError', listener: (err: Error, socket: stream.Duplex) => void): this;
         prependOnceListener(event: 'connect', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
+        prependOnceListener(event: 'dropRequest', listener: (req: InstanceType<Request>, socket: stream.Duplex) => void): this;
         prependOnceListener(event: 'request', listener: RequestListener<Request, Response>): this;
         prependOnceListener(event: 'upgrade', listener: (req: InstanceType<Request>, socket: stream.Duplex, head: Buffer) => void): this;
     }
@@ -456,6 +476,22 @@ declare module 'http' {
          * @param value Header value
          */
         setHeader(name: string, value: number | string | ReadonlyArray<string>): this;
+        /**
+         * Append a single header value for the header object.
+         *
+         * If the value is an array, this is equivalent of calling this method multiple
+         * times.
+         *
+         * If there were no previous value for the header, this is equivalent of calling `outgoingMessage.setHeader(name, value)`.
+         *
+         * Depending of the value of `options.uniqueHeaders` when the client request or the
+         * server were created, this will end up in the header being sent multiple times or
+         * a single time with values joined using `; `.
+         * @since v18.3.0, v16.17.0
+         * @param name Header name
+         * @param value Header value
+         */
+        appendHeader(name: string, value: string | ReadonlyArray<string>): this;
         /**
          * Gets the value of the HTTP header with the given name. If that header is not
          * set, the returned value will be `undefined`.
@@ -582,6 +618,13 @@ declare module 'http' {
          * @since v0.11.8
          */
         statusMessage: string;
+        /**
+         * If set to `true`, Node.js will check whether the `Content-Length`header value and the size of the body, in bytes, are equal.
+         * Mismatching the `Content-Length` header value will result
+         * in an `Error` being thrown, identified by `code:``'ERR_HTTP_CONTENT_LENGTH_MISMATCH'`.
+         * @since v18.10.0, v16.18.0
+         */
+        strictContentLength: boolean;
         constructor(req: Request);
         assignSocket(socket: Socket): void;
         detachSocket(socket: Socket): void;
@@ -1049,6 +1092,21 @@ declare module 'http' {
          * @since v0.1.5
          */
         headers: IncomingHttpHeaders;
+        /**
+         * Similar to `message.headers`, but there is no join logic and the values are
+         * always arrays of strings, even for headers received just once.
+         *
+         * ```js
+         * // Prints something like:
+         * //
+         * // { 'user-agent': ['curl/7.22.0'],
+         * //   host: ['127.0.0.1:8000'],
+         * //   accept: ['*'] }
+         * console.log(request.headersDistinct);
+         * ```
+         * @since v18.3.0, v16.17.0
+         */
+        headersDistinct: NodeJS.Dict<string[]>;
         /**
          * The raw request/response headers list exactly as they were received.
          *
@@ -1079,6 +1137,13 @@ declare module 'http' {
          * @since v0.3.0
          */
         trailers: NodeJS.Dict<string>;
+        /**
+         * Similar to `message.trailers`, but there is no join logic and the values are
+         * always arrays of strings, even for headers received just once.
+         * Only populated at the `'end'` event.
+         * @since v18.3.0, v16.17.0
+         */
+        trailersDistinct: NodeJS.Dict<string[]>;
         /**
          * The raw request/response trailer keys and values exactly as they were
          * received. Only populated at the `'end'` event.
@@ -1600,7 +1665,7 @@ declare module 'http' {
      * }
      * ```
      * @since v14.3.0
-     * @param [name='Header name'] Label for error message.
+     * @param [label='Header name'] Label for error message.
      */
     function validateHeaderName(name: string): void;
     /**

node/ts4.8/http2.d.ts

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

node/ts4.8/https.d.ts

@@ -1,7 +1,7 @@
 /**
  * HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
  * separate module.
- * @see [source](https://github.com/nodejs/node/blob/v20.0.0/lib/https.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/https.js)
  */
 declare module 'https' {
     import { Duplex } from 'node:stream';

node/ts4.8/inspector.d.ts

@@ -22,7 +22,7 @@
  * ```js
  * import * as inspector from 'node:inspector';
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.0.0/lib/inspector.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/inspector.js)
  */
 declare module 'inspector' {
     import EventEmitter = require('node:events');

node/ts4.8/net.d.ts

@@ -10,7 +10,7 @@
  * ```js
  * const net = require('node:net');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.0.0/lib/net.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/net.js)
  */
 declare module 'net' {
     import * as stream from 'node:stream';
@@ -266,6 +266,12 @@ declare module 'net' {
          * @since v6.1.0
          */
         readonly connecting: boolean;
+        /**
+         * This is `true` if the socket is not connected yet, either because `.connect()`has not yet been called or because it is still in the process of connecting
+         * (see `socket.connecting`).
+         * @since v11.2.0, v10.16.0
+         */
+        readonly pending: boolean;
         /**
          * See `writable.destroyed` for further details.
          */
@@ -287,12 +293,6 @@ declare module 'net' {
          * @since v18.8.0, v16.18.0
          */
         readonly localFamily?: string;
-        /**
-         * This is `true` if the socket is not connected yet, either because `.connect()`has not yet been called or because it is still in the process of connecting
-         * (see `socket.connecting`).
-         * @since v11.2.0, v10.16.0
-         */
-        readonly pending: boolean;
         /**
          * This property represents the state of the connection as a string.
          *

node/ts4.8/os.d.ts

@@ -5,7 +5,7 @@
  * ```js
  * const os = require('node:os');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.0.0/lib/os.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/os.js)
  */
 declare module 'os' {
     interface CpuInfo {

node/ts4.8/path.d.ts

@@ -13,7 +13,7 @@ declare module 'path/win32' {
  * ```js
  * const path = require('node:path');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.0.0/lib/path.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/path.js)
  */
 declare module 'path' {
     namespace path {

node/ts4.8/perf_hooks.d.ts

@@ -27,7 +27,7 @@
  *   performance.measure('A to B', 'A', 'B');
  * });
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.0.0/lib/perf_hooks.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/perf_hooks.js)
  */
 declare module 'perf_hooks' {
     import { AsyncResource } from 'node:async_hooks';

node/ts4.8/punycode.d.ts

@@ -24,7 +24,7 @@
  * made available to developers as a convenience. Fixes or other modifications to
  * the module must be directed to the [Punycode.js](https://github.com/bestiejs/punycode.js) project.
  * @deprecated Since v7.0.0 - Deprecated
- * @see [source](https://github.com/nodejs/node/blob/v20.0.0/lib/punycode.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/punycode.js)
  */
 declare module 'punycode' {
     /**

node/ts4.8/querystring.d.ts

@@ -9,7 +9,7 @@
  * `querystring` is more performant than `URLSearchParams` but is not a
  * standardized API. Use `URLSearchParams` when performance is not critical or
  * when compatibility with browser code is desirable.
- * @see [source](https://github.com/nodejs/node/blob/v20.0.0/lib/querystring.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/querystring.js)
  */
 declare module 'querystring' {
     interface StringifyOptions {

node/ts4.8/readline.d.ts

@@ -30,7 +30,7 @@
  *
  * Once this code is invoked, the Node.js application will not terminate until the`readline.Interface` is closed because the interface waits for data to be
  * received on the `input` stream.
- * @see [source](https://github.com/nodejs/node/blob/v20.0.0/lib/readline.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/readline.js)
  */
 declare module 'readline' {
     import { Abortable, EventEmitter } from 'node:events';

node/ts4.8/repl.d.ts

@@ -6,7 +6,7 @@
  * ```js
  * const repl = require('node:repl');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.0.0/lib/repl.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/repl.js)
  */
 declare module 'repl' {
     import { Interface, Completer, AsyncCompleter } from 'node:readline';

node/ts4.8/stream.d.ts

@@ -14,7 +14,7 @@
  *
  * The `node:stream` module is useful for creating new types of stream instances.
  * It is usually not necessary to use the `node:stream` module to consume streams.
- * @see [source](https://github.com/nodejs/node/blob/v20.0.0/lib/stream.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/stream.js)
  */
 declare module 'stream' {
     import { EventEmitter, Abortable } from 'node:events';
@@ -1131,6 +1131,20 @@ declare module 'stream' {
          * @param stream a stream to attach a signal to
          */
         function addAbortSignal<T extends Stream>(signal: AbortSignal, stream: T): T;
+        /**
+         * Returns the default highWaterMark used by streams.
+         * Defaults to `16384` (16 KiB), or `16` for `objectMode`.
+         * @since v19.9.0
+         * @param objectMode
+         */
+        function getDefaultHighWaterMark(objectMode: boolean): number;
+        /**
+         * Sets the default highWaterMark used by streams.
+         * @since v19.9.0
+         * @param objectMode
+         * @param value highWaterMark value
+         */
+        function setDefaultHighWaterMark(objectMode: boolean, value: number): void;
         interface FinishedOptions extends Abortable {
             error?: boolean | undefined;
             readable?: boolean | undefined;

node/ts4.8/string_decoder.d.ts

@@ -36,7 +36,7 @@
  * decoder.write(Buffer.from([0x82]));
  * console.log(decoder.end(Buffer.from([0xAC])));
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.0.0/lib/string_decoder.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.1.0/lib/string_decoder.js)
  */
 declare module 'string_decoder' {
     class StringDecoder {