@types/node 20.3.2 → 20.4.0

node/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.
 
 ### Additional Details
- * Last updated: Mon, 26 Jun 2023 20:02:42 GMT
+ * Last updated: Wed, 05 Jul 2023 21:32:40 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`, `structuredClone`
 

node/buffer.d.ts

@@ -530,7 +530,7 @@ declare module 'buffer' {
              * @param [fill=0] A value to pre-fill the new `Buffer` with.
              * @param [encoding='utf8'] If `fill` is a string, this is its encoding.
              */
-            alloc(size: number, fill?: string | Buffer | number, encoding?: BufferEncoding): Buffer;
+            alloc(size: number, fill?: string | Uint8Array | number, encoding?: BufferEncoding): Buffer;
             /**
              * Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_OUT_OF_RANGE` is thrown.
              *

node/crypto.d.ts

@@ -1516,10 +1516,15 @@ declare module 'crypto' {
     class DiffieHellman {
         private constructor();
         /**
-         * Generates private and public Diffie-Hellman key values, and returns
+         * Generates private and public Diffie-Hellman key values unless they have been
+         * generated or computed already, and returns
          * the public key in the specified `encoding`. This key should be
          * transferred to the other party.
          * If `encoding` is provided a string is returned; otherwise a `Buffer` is returned.
+         *
+         * This function is a thin wrapper around [`DH_generate_key()`](https://www.openssl.org/docs/man3.0/man3/DH_generate_key.html). In particular,
+         * once a private key has been generated or set, calling this function only updates
+         * the public key but does not generate a new private key.
          * @since v0.5.0
          * @param encoding The `encoding` of the return value.
          */
@@ -1591,6 +1596,9 @@ declare module 'crypto' {
          * Sets the Diffie-Hellman private key. If the `encoding` argument is provided,`privateKey` is expected
          * to be a string. If no `encoding` is provided, `privateKey` is expected
          * to be a `Buffer`, `TypedArray`, or `DataView`.
+         *
+         * This function does not automatically compute the associated public key. Either `diffieHellman.setPublicKey()` or `diffieHellman.generateKeys()` can be
+         * used to manually provide the public key or to automatically derive it.
          * @since v0.5.0
          * @param encoding The `encoding` of the `privateKey` string.
          */

node/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for non-npm package Node.js 20.3
+// Type definitions for non-npm package Node.js 20.4
 // Project: https://nodejs.org/
 // Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
 //                 DefinitelyTyped <https://github.com/DefinitelyTyped>

node/module.d.ts

@@ -73,11 +73,24 @@ declare module 'module' {
             readonly payload: SourceMapPayload;
             constructor(payload: SourceMapPayload);
             /**
-             * Given a line number and column number in the generated source file, returns
-             * an object representing the position in the original file. The object returned
-             * consists of the following keys:
+             * Given a line offset and column offset in the generated source
+             * file, returns an object representing the SourceMap range in the
+             * original file if found, or an empty object if not.
+             *
+             * The object returned contains the following keys:
+             *
+             * The returned value represents the raw range as it appears in the
+             * SourceMap, based on zero-indexed offsets, _not_ 1-indexed line and
+             * column numbers as they appear in Error messages and CallSite
+             * objects.
+             *
+             * To get the corresponding 1-indexed line and column numbers from a
+             * lineNumber and columnNumber as they are reported by Error stacks
+             * and CallSite objects, use `sourceMap.findOrigin(lineNumber, columnNumber)`
+             * @param lineOffset The zero-indexed line number offset in the generated source
+             * @param columnOffset The zero-indexed column number offset in the generated source
              */
-            findEntry(line: number, column: number): SourceMapping;
+            findEntry(lineOffset: number, columnOffset: number): SourceMapping;
         }
     }
     interface Module extends NodeModule {}

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "20.3.2",
+    "version": "20.4.0",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -232,6 +232,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "77b1f16021a42a5f28f9061a3922380bdc6bcd9630c2405d53ff935c6538793c",
+    "typesPublisherContentHash": "c342b7a9708bb206f3dfc674c1d142bfdaf5a01b59dc5d8bd88d18fc226c2de3",
     "typeScriptVersion": "4.3"
 }

node/test.d.ts

@@ -159,7 +159,7 @@ declare module 'node:test' {
      * @param [name='The name'] The name of the suite, which is displayed when reporting test results.
      * @param options Configuration options for the suite. supports the same options as `test([name][, options][, fn])`.
      * @param [fn='A no-op function'] The function under suite declaring all subtests and subsuites. The first argument to this function is a {@link SuiteContext} object.
-     * @return `undefined`.
+     * @return Immediately fulfilled with `undefined`.
      */
     function describe(name?: string, options?: TestOptions, fn?: SuiteFn): void;
     function describe(name?: string, fn?: SuiteFn): void;
@@ -821,6 +821,7 @@ declare module 'node:test' {
          * @since v19.1.0, v18.13.0
          */
         restoreAll(): void;
+        timers: MockTimers;
     }
     const mock: MockTracker;
     interface MockFunctionCall<
@@ -964,6 +965,216 @@ declare module 'node:test' {
          */
         restore(): void;
     }
+    type Timer = 'setInterval' | 'clearInterval' | 'setTimeout' | 'clearTimeout';
+    /**
+     * Mocking timers is a technique commonly used in software testing to simulate and
+     * control the behavior of timers, such as `setInterval` and `setTimeout`,
+     * without actually waiting for the specified time intervals.
+     *
+     * The `MockTracker` provides a top-level `timers` export
+     * which is a `MockTimers` instance.
+     * @since v20.4.0
+     * @experimental
+     */
+    class MockTimers {
+        /**
+         * Enables timer mocking for the specified timers.
+         *
+         * **Note:** When you enable mocking for a specific timer, its associated
+         * clear function will also be implicitly mocked.
+         *
+         * Example usage:
+         *
+         * ```js
+         * import { mock } from 'node:test';
+         * mock.timers.enable(['setInterval']);
+         * ```
+         *
+         * ```js
+         * const { mock } = require('node:test');
+         * mock.timers.enable(['setInterval']);
+         * ```
+         *
+         * The above example enables mocking for the `setInterval` timer and
+         * implicitly mocks the `clearInterval` function. Only the `setInterval`and `clearInterval` functions from `node:timers`,`node:timers/promises`, and`globalThis` will be mocked.
+         *
+         * Alternatively, if you call `mock.timers.enable()` without any parameters:
+         *
+         * All timers (`'setInterval'`, `'clearInterval'`, `'setTimeout'`, and `'clearTimeout'`)
+         * will be mocked. The `setInterval`, `clearInterval`, `setTimeout`, and `clearTimeout`functions from `node:timers`, `node:timers/promises`,
+         * and `globalThis` will be mocked.
+         * @since v20.4.0
+         */
+        enable(timers?: Timer[]): void;
+        /**
+         * This function restores the default behavior of all mocks that were previously
+         * created by this `MockTimers` instance and disassociates the mocks
+         * from the `MockTracker` instance.
+         *
+         * **Note:** After each test completes, this function is called on
+         * the test context's `MockTracker`.
+         *
+         * ```js
+         * import { mock } from 'node:test';
+         * mock.timers.reset();
+         * ```
+         *
+         * ```js
+         * const { mock } = require('node:test');
+         * mock.timers.reset();
+         * ```
+         * @since v20.4.0
+         */
+        reset(): void;
+        /**
+         * Advances time for all mocked timers.
+         *
+         * **Note:** This diverges from how `setTimeout` in Node.js behaves and accepts
+         * only positive numbers. In Node.js, `setTimeout` with negative numbers is
+         * only supported for web compatibility reasons.
+         *
+         * The following example mocks a `setTimeout` function and
+         * by using `.tick` advances in
+         * time triggering all pending timers.
+         *
+         * ```js
+         * import assert from 'node:assert';
+         * import { test } from 'node:test';
+         *
+         * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+         *   const fn = context.mock.fn();
+         *
+         *   context.mock.timers.enable(['setTimeout']);
+         *
+         *   setTimeout(fn, 9999);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 0);
+         *
+         *   // Advance in time
+         *   context.mock.timers.tick(9999);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 1);
+         * });
+         * ```
+         *
+         * ```js
+         * const assert = require('node:assert');
+         * const { test } = require('node:test');
+         *
+         * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+         *   const fn = context.mock.fn();
+         *   context.mock.timers.enable(['setTimeout']);
+         *
+         *   setTimeout(fn, 9999);
+         *   assert.strictEqual(fn.mock.callCount(), 0);
+         *
+         *   // Advance in time
+         *   context.mock.timers.tick(9999);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 1);
+         * });
+         * ```
+         *
+         * Alternativelly, the `.tick` function can be called many times
+         *
+         * ```js
+         * import assert from 'node:assert';
+         * import { test } from 'node:test';
+         *
+         * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+         *   const fn = context.mock.fn();
+         *   context.mock.timers.enable(['setTimeout']);
+         *   const nineSecs = 9000;
+         *   setTimeout(fn, nineSecs);
+         *
+         *   const twoSeconds = 3000;
+         *   context.mock.timers.tick(twoSeconds);
+         *   context.mock.timers.tick(twoSeconds);
+         *   context.mock.timers.tick(twoSeconds);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 1);
+         * });
+         * ```
+         *
+         * ```js
+         * const assert = require('node:assert');
+         * const { test } = require('node:test');
+         *
+         * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+         *   const fn = context.mock.fn();
+         *   context.mock.timers.enable(['setTimeout']);
+         *   const nineSecs = 9000;
+         *   setTimeout(fn, nineSecs);
+         *
+         *   const twoSeconds = 3000;
+         *   context.mock.timers.tick(twoSeconds);
+         *   context.mock.timers.tick(twoSeconds);
+         *   context.mock.timers.tick(twoSeconds);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 1);
+         * });
+         * ```
+         * @since v20.4.0
+         */
+        tick(milliseconds: number): void;
+        /**
+         * Triggers all pending mocked timers immediately.
+         *
+         * The example below triggers all pending timers immediately,
+         * causing them to execute without any delay.
+         *
+         * ```js
+         * import assert from 'node:assert';
+         * import { test } from 'node:test';
+         *
+         * test('runAll functions following the given order', (context) => {
+         *   context.mock.timers.enable(['setTimeout']);
+         *   const results = [];
+         *   setTimeout(() => results.push(1), 9999);
+         *
+         *   // Notice that if both timers have the same timeout,
+         *   // the order of execution is guaranteed
+         *   setTimeout(() => results.push(3), 8888);
+         *   setTimeout(() => results.push(2), 8888);
+         *
+         *   assert.deepStrictEqual(results, []);
+         *
+         *   context.mock.timers.runAll();
+         *
+         *   assert.deepStrictEqual(results, [3, 2, 1]);
+         * });
+         * ```
+         *
+         * ```js
+         * const assert = require('node:assert');
+         * const { test } = require('node:test');
+         *
+         * test('runAll functions following the given order', (context) => {
+         *   context.mock.timers.enable(['setTimeout']);
+         *   const results = [];
+         *   setTimeout(() => results.push(1), 9999);
+         *
+         *   // Notice that if both timers have the same timeout,
+         *   // the order of execution is guaranteed
+         *   setTimeout(() => results.push(3), 8888);
+         *   setTimeout(() => results.push(2), 8888);
+         *
+         *   assert.deepStrictEqual(results, []);
+         *
+         *   context.mock.timers.runAll();
+         *
+         *   assert.deepStrictEqual(results, [3, 2, 1]);
+         * });
+         * ```
+         *
+         * **Note:** The `runAll()` function is specifically designed for
+         * triggering timers in the context of timer mocking.
+         * It does not have any effect on real-time system
+         * clocks or actual timers outside of the mocking environment.
+         * @since v20.4.0
+         */
+        runAll(): void;
+    }
     export { test as default, run, test, describe, it, before, after, beforeEach, afterEach, mock, skip, only, todo };
 }
 
@@ -1139,7 +1350,7 @@ declare module 'node:test/reporters' {
      * where each passing test is represented by a `.`,
      * and each failing test is represented by a `X`.
      */
-    function dot(source: TestEventGenerator): AsyncGenerator<"\n" | "." | "X", void>;
+    function dot(source: TestEventGenerator): AsyncGenerator<'\n' | '.' | 'X', void>;
     /**
      * The `tap` reporter outputs the test results in the [TAP](https://testanything.org/) format.
      */

node/tls.d.ts

@@ -728,6 +728,17 @@ declare module 'tls' {
     }
     type SecureVersion = 'TLSv1.3' | 'TLSv1.2' | 'TLSv1.1' | 'TLSv1';
     interface SecureContextOptions {
+        /**
+         * If set, this will be called when a client opens a connection using the ALPN extension.
+         * One argument will be passed to the callback: an object containing `servername` and `protocols` fields,
+         * respectively containing the server name from the SNI extension (if any) and an array of
+         * ALPN protocol name strings. The callback must return either one of the strings listed in `protocols`,
+         * which will be returned to the client as the selected ALPN protocol, or `undefined`,
+         * to reject the connection with a fatal alert. If a string is returned that does not match one of
+         * the client's ALPN protocols, an error will be thrown.
+         * This option cannot be used with the `ALPNProtocols` option, and setting both options will throw an error.
+         */
+        ALPNCallback?: ((arg: { servername: string; protocols: string[] }) => string | undefined) | undefined;
         /**
          * Optionally override the trusted CA certificates. Default is to trust
          * the well-known CAs curated by Mozilla. Mozilla's CAs are completely

node/ts4.8/crypto.d.ts

@@ -1516,10 +1516,15 @@ declare module 'crypto' {
     class DiffieHellman {
         private constructor();
         /**
-         * Generates private and public Diffie-Hellman key values, and returns
+         * Generates private and public Diffie-Hellman key values unless they have been
+         * generated or computed already, and returns
          * the public key in the specified `encoding`. This key should be
          * transferred to the other party.
          * If `encoding` is provided a string is returned; otherwise a `Buffer` is returned.
+         *
+         * This function is a thin wrapper around [`DH_generate_key()`](https://www.openssl.org/docs/man3.0/man3/DH_generate_key.html). In particular,
+         * once a private key has been generated or set, calling this function only updates
+         * the public key but does not generate a new private key.
          * @since v0.5.0
          * @param encoding The `encoding` of the return value.
          */
@@ -1591,6 +1596,9 @@ declare module 'crypto' {
          * Sets the Diffie-Hellman private key. If the `encoding` argument is provided,`privateKey` is expected
          * to be a string. If no `encoding` is provided, `privateKey` is expected
          * to be a `Buffer`, `TypedArray`, or `DataView`.
+         *
+         * This function does not automatically compute the associated public key. Either `diffieHellman.setPublicKey()` or `diffieHellman.generateKeys()` can be
+         * used to manually provide the public key or to automatically derive it.
          * @since v0.5.0
          * @param encoding The `encoding` of the `privateKey` string.
          */

node/ts4.8/module.d.ts

@@ -73,11 +73,24 @@ declare module 'module' {
             readonly payload: SourceMapPayload;
             constructor(payload: SourceMapPayload);
             /**
-             * Given a line number and column number in the generated source file, returns
-             * an object representing the position in the original file. The object returned
-             * consists of the following keys:
+             * Given a line offset and column offset in the generated source
+             * file, returns an object representing the SourceMap range in the
+             * original file if found, or an empty object if not.
+             *
+             * The object returned contains the following keys:
+             *
+             * The returned value represents the raw range as it appears in the
+             * SourceMap, based on zero-indexed offsets, _not_ 1-indexed line and
+             * column numbers as they appear in Error messages and CallSite
+             * objects.
+             *
+             * To get the corresponding 1-indexed line and column numbers from a
+             * lineNumber and columnNumber as they are reported by Error stacks
+             * and CallSite objects, use `sourceMap.findOrigin(lineNumber, columnNumber)`
+             * @param lineOffset The zero-indexed line number offset in the generated source
+             * @param columnOffset The zero-indexed column number offset in the generated source
              */
-            findEntry(line: number, column: number): SourceMapping;
+            findEntry(lineOffset: number, columnOffset: number): SourceMapping;
         }
     }
     interface Module extends NodeModule {}

node/ts4.8/test.d.ts

@@ -159,7 +159,7 @@ declare module 'node:test' {
      * @param [name='The name'] The name of the suite, which is displayed when reporting test results.
      * @param options Configuration options for the suite. supports the same options as `test([name][, options][, fn])`.
      * @param [fn='A no-op function'] The function under suite declaring all subtests and subsuites. The first argument to this function is a {@link SuiteContext} object.
-     * @return `undefined`.
+     * @return Immediately fulfilled with `undefined`.
      */
     function describe(name?: string, options?: TestOptions, fn?: SuiteFn): void;
     function describe(name?: string, fn?: SuiteFn): void;
@@ -821,6 +821,7 @@ declare module 'node:test' {
          * @since v19.1.0, v18.13.0
          */
         restoreAll(): void;
+        timers: MockTimers;
     }
     const mock: MockTracker;
     interface MockFunctionCall<
@@ -964,6 +965,216 @@ declare module 'node:test' {
          */
         restore(): void;
     }
+    type Timer = 'setInterval' | 'clearInterval' | 'setTimeout' | 'clearTimeout';
+    /**
+     * Mocking timers is a technique commonly used in software testing to simulate and
+     * control the behavior of timers, such as `setInterval` and `setTimeout`,
+     * without actually waiting for the specified time intervals.
+     *
+     * The `MockTracker` provides a top-level `timers` export
+     * which is a `MockTimers` instance.
+     * @since v20.4.0
+     * @experimental
+     */
+    class MockTimers {
+        /**
+         * Enables timer mocking for the specified timers.
+         *
+         * **Note:** When you enable mocking for a specific timer, its associated
+         * clear function will also be implicitly mocked.
+         *
+         * Example usage:
+         *
+         * ```js
+         * import { mock } from 'node:test';
+         * mock.timers.enable(['setInterval']);
+         * ```
+         *
+         * ```js
+         * const { mock } = require('node:test');
+         * mock.timers.enable(['setInterval']);
+         * ```
+         *
+         * The above example enables mocking for the `setInterval` timer and
+         * implicitly mocks the `clearInterval` function. Only the `setInterval`and `clearInterval` functions from `node:timers`,`node:timers/promises`, and`globalThis` will be mocked.
+         *
+         * Alternatively, if you call `mock.timers.enable()` without any parameters:
+         *
+         * All timers (`'setInterval'`, `'clearInterval'`, `'setTimeout'`, and `'clearTimeout'`)
+         * will be mocked. The `setInterval`, `clearInterval`, `setTimeout`, and `clearTimeout`functions from `node:timers`, `node:timers/promises`,
+         * and `globalThis` will be mocked.
+         * @since v20.4.0
+         */
+        enable(timers?: Timer[]): void;
+        /**
+         * This function restores the default behavior of all mocks that were previously
+         * created by this `MockTimers` instance and disassociates the mocks
+         * from the `MockTracker` instance.
+         *
+         * **Note:** After each test completes, this function is called on
+         * the test context's `MockTracker`.
+         *
+         * ```js
+         * import { mock } from 'node:test';
+         * mock.timers.reset();
+         * ```
+         *
+         * ```js
+         * const { mock } = require('node:test');
+         * mock.timers.reset();
+         * ```
+         * @since v20.4.0
+         */
+        reset(): void;
+        /**
+         * Advances time for all mocked timers.
+         *
+         * **Note:** This diverges from how `setTimeout` in Node.js behaves and accepts
+         * only positive numbers. In Node.js, `setTimeout` with negative numbers is
+         * only supported for web compatibility reasons.
+         *
+         * The following example mocks a `setTimeout` function and
+         * by using `.tick` advances in
+         * time triggering all pending timers.
+         *
+         * ```js
+         * import assert from 'node:assert';
+         * import { test } from 'node:test';
+         *
+         * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+         *   const fn = context.mock.fn();
+         *
+         *   context.mock.timers.enable(['setTimeout']);
+         *
+         *   setTimeout(fn, 9999);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 0);
+         *
+         *   // Advance in time
+         *   context.mock.timers.tick(9999);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 1);
+         * });
+         * ```
+         *
+         * ```js
+         * const assert = require('node:assert');
+         * const { test } = require('node:test');
+         *
+         * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+         *   const fn = context.mock.fn();
+         *   context.mock.timers.enable(['setTimeout']);
+         *
+         *   setTimeout(fn, 9999);
+         *   assert.strictEqual(fn.mock.callCount(), 0);
+         *
+         *   // Advance in time
+         *   context.mock.timers.tick(9999);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 1);
+         * });
+         * ```
+         *
+         * Alternativelly, the `.tick` function can be called many times
+         *
+         * ```js
+         * import assert from 'node:assert';
+         * import { test } from 'node:test';
+         *
+         * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+         *   const fn = context.mock.fn();
+         *   context.mock.timers.enable(['setTimeout']);
+         *   const nineSecs = 9000;
+         *   setTimeout(fn, nineSecs);
+         *
+         *   const twoSeconds = 3000;
+         *   context.mock.timers.tick(twoSeconds);
+         *   context.mock.timers.tick(twoSeconds);
+         *   context.mock.timers.tick(twoSeconds);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 1);
+         * });
+         * ```
+         *
+         * ```js
+         * const assert = require('node:assert');
+         * const { test } = require('node:test');
+         *
+         * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+         *   const fn = context.mock.fn();
+         *   context.mock.timers.enable(['setTimeout']);
+         *   const nineSecs = 9000;
+         *   setTimeout(fn, nineSecs);
+         *
+         *   const twoSeconds = 3000;
+         *   context.mock.timers.tick(twoSeconds);
+         *   context.mock.timers.tick(twoSeconds);
+         *   context.mock.timers.tick(twoSeconds);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 1);
+         * });
+         * ```
+         * @since v20.4.0
+         */
+        tick(milliseconds: number): void;
+        /**
+         * Triggers all pending mocked timers immediately.
+         *
+         * The example below triggers all pending timers immediately,
+         * causing them to execute without any delay.
+         *
+         * ```js
+         * import assert from 'node:assert';
+         * import { test } from 'node:test';
+         *
+         * test('runAll functions following the given order', (context) => {
+         *   context.mock.timers.enable(['setTimeout']);
+         *   const results = [];
+         *   setTimeout(() => results.push(1), 9999);
+         *
+         *   // Notice that if both timers have the same timeout,
+         *   // the order of execution is guaranteed
+         *   setTimeout(() => results.push(3), 8888);
+         *   setTimeout(() => results.push(2), 8888);
+         *
+         *   assert.deepStrictEqual(results, []);
+         *
+         *   context.mock.timers.runAll();
+         *
+         *   assert.deepStrictEqual(results, [3, 2, 1]);
+         * });
+         * ```
+         *
+         * ```js
+         * const assert = require('node:assert');
+         * const { test } = require('node:test');
+         *
+         * test('runAll functions following the given order', (context) => {
+         *   context.mock.timers.enable(['setTimeout']);
+         *   const results = [];
+         *   setTimeout(() => results.push(1), 9999);
+         *
+         *   // Notice that if both timers have the same timeout,
+         *   // the order of execution is guaranteed
+         *   setTimeout(() => results.push(3), 8888);
+         *   setTimeout(() => results.push(2), 8888);
+         *
+         *   assert.deepStrictEqual(results, []);
+         *
+         *   context.mock.timers.runAll();
+         *
+         *   assert.deepStrictEqual(results, [3, 2, 1]);
+         * });
+         * ```
+         *
+         * **Note:** The `runAll()` function is specifically designed for
+         * triggering timers in the context of timer mocking.
+         * It does not have any effect on real-time system
+         * clocks or actual timers outside of the mocking environment.
+         * @since v20.4.0
+         */
+        runAll(): void;
+    }
     export { test as default, run, test, describe, it, before, after, beforeEach, afterEach, mock, skip, only, todo };
 }
 
@@ -1139,7 +1350,7 @@ declare module 'node:test/reporters' {
      * where each passing test is represented by a `.`,
      * and each failing test is represented by a `X`.
      */
-    function dot(source: TestEventGenerator): AsyncGenerator<"\n" | "." | "X", void>;
+    function dot(source: TestEventGenerator): AsyncGenerator<'\n' | '.' | 'X', void>;
     /**
      * The `tap` reporter outputs the test results in the [TAP](https://testanything.org/) format.
      */

node/ts4.8/tls.d.ts

@@ -728,6 +728,17 @@ declare module 'tls' {
     }
     type SecureVersion = 'TLSv1.3' | 'TLSv1.2' | 'TLSv1.1' | 'TLSv1';
     interface SecureContextOptions {
+        /**
+         * If set, this will be called when a client opens a connection using the ALPN extension.
+         * One argument will be passed to the callback: an object containing `servername` and `protocols` fields,
+         * respectively containing the server name from the SNI extension (if any) and an array of
+         * ALPN protocol name strings. The callback must return either one of the strings listed in `protocols`,
+         * which will be returned to the client as the selected ALPN protocol, or `undefined`,
+         * to reject the connection with a fatal alert. If a string is returned that does not match one of
+         * the client's ALPN protocols, an error will be thrown.
+         * This option cannot be used with the `ALPNProtocols` option, and setting both options will throw an error.
+         */
+        ALPNCallback?: ((arg: { servername: string; protocols: string[] }) => string | undefined) | undefined;
         /**
          * Optionally override the trusted CA certificates. Default is to trust
          * the well-known CAs curated by Mozilla. Mozilla's CAs are completely

node/ts4.8/util.d.ts

@@ -1460,32 +1460,72 @@ declare module 'util' {
 
         /**
          * Gets and sets the type portion of the MIME.
+         *
+         * ```js
+         * import { MIMEType } from 'node:util';
+         *
+         * const myMIME = new MIMEType('text/javascript');
+         * console.log(myMIME.type);
+         * // Prints: text
+         * myMIME.type = 'application';
+         * console.log(myMIME.type);
+         * // Prints: application
+         * console.log(String(myMIME));
+         * // Prints: application/javascript
+         * ```
          */
         type: string;
         /**
          * Gets and sets the subtype portion of the MIME.
+         *
+         * ```js
+         * import { MIMEType } from 'node:util';
+         *
+         * const myMIME = new MIMEType('text/ecmascript');
+         * console.log(myMIME.subtype);
+         * // Prints: ecmascript
+         * myMIME.subtype = 'javascript';
+         * console.log(myMIME.subtype);
+         * // Prints: javascript
+         * console.log(String(myMIME));
+         * // Prints: text/javascript
+         * ```
          */
         subtype: string;
         /**
-         * Gets the essence of the MIME.
-         *
+         * Gets the essence of the MIME. This property is read only.
          * Use `mime.type` or `mime.subtype` to alter the MIME.
+         *
+         * ```js
+         * import { MIMEType } from 'node:util';
+         *
+         * const myMIME = new MIMEType('text/javascript;key=value');
+         * console.log(myMIME.essence);
+         * // Prints: text/javascript
+         * myMIME.type = 'application';
+         * console.log(myMIME.essence);
+         * // Prints: application/javascript
+         * console.log(String(myMIME));
+         * // Prints: application/javascript;key=value
+         * ```
          */
         readonly essence: string;
         /**
-         * Gets the `MIMEParams` object representing the parameters of the MIME.
+         * Gets the `MIMEParams` object representing the
+         * parameters of the MIME. This property is read-only. See `MIMEParams` documentation for details.
          */
         readonly params: MIMEParams;
         /**
-         * Returns the serialized MIME.
+         * The `toString()` method on the `MIMEType` object returns the serialized MIME.
          *
-         * Because of the need for standard compliance, this method
-         * does not allow users to customize the serialization process of the MIME.
+         * Because of the need for standard compliance, this method does not allow users
+         * to customize the serialization process of the MIME.
          */
         toString(): string;
     }
     /**
-     * @since v18.13.0
+     * The `MIMEParams` API provides read and write access to the parameters of a`MIMEType`.
+     * @since v19.1.0, v18.13.0
      */
     export class MIMEParams {
         /**
@@ -1494,11 +1534,14 @@ declare module 'util' {
         delete(name: string): void;
         /**
          * Returns an iterator over each of the name-value pairs in the parameters.
+         * Each item of the iterator is a JavaScript `Array`. The first item of the array
+         * is the `name`, the second item of the array is the `value`.
          */
         entries(): IterableIterator<[string, string]>;
         /**
-         * Returns the value of the first name-value pair whose name is `name`.
-         * If there are no such pairs, `null` is returned.
+         * Returns the value of the first name-value pair whose name is `name`. If there
+         * are no such pairs, `null` is returned.
+         * @return or `null` if there is no name-value pair with the given `name`.
          */
         get(name: string): string | null;
         /**
@@ -1507,12 +1550,33 @@ declare module 'util' {
         has(name: string): boolean;
         /**
          * Returns an iterator over the names of each name-value pair.
+         *
+         * ```js
+         * import { MIMEType } from 'node:util';
+         *
+         * const { params } = new MIMEType('text/plain;foo=0;bar=1');
+         * for (const name of params.keys()) {
+         *   console.log(name);
+         * }
+         * // Prints:
+         * //   foo
+         * //   bar
+         * ```
          */
         keys(): IterableIterator<string>;
         /**
-         * Sets the value in the `MIMEParams` object associated with `name` to `value`.
-         * If there are any pre-existing name-value pairs whose names are `name`,
+         * Sets the value in the `MIMEParams` object associated with `name` to`value`. If there are any pre-existing name-value pairs whose names are `name`,
          * set the first such pair's value to `value`.
+         *
+         * ```js
+         * import { MIMEType } from 'node:util';
+         *
+         * const { params } = new MIMEType('text/plain;foo=0;bar=1');
+         * params.set('foo', 'def');
+         * params.set('baz', 'xyz');
+         * console.log(params.toString());
+         * // Prints: foo=def&#x26;bar=1&#x26;baz=xyz
+         * ```
          */
         set(name: string, value: string): void;
         /**

node/util.d.ts

@@ -1460,32 +1460,72 @@ declare module 'util' {
 
         /**
          * Gets and sets the type portion of the MIME.
+         *
+         * ```js
+         * import { MIMEType } from 'node:util';
+         *
+         * const myMIME = new MIMEType('text/javascript');
+         * console.log(myMIME.type);
+         * // Prints: text
+         * myMIME.type = 'application';
+         * console.log(myMIME.type);
+         * // Prints: application
+         * console.log(String(myMIME));
+         * // Prints: application/javascript
+         * ```
          */
         type: string;
         /**
          * Gets and sets the subtype portion of the MIME.
+         *
+         * ```js
+         * import { MIMEType } from 'node:util';
+         *
+         * const myMIME = new MIMEType('text/ecmascript');
+         * console.log(myMIME.subtype);
+         * // Prints: ecmascript
+         * myMIME.subtype = 'javascript';
+         * console.log(myMIME.subtype);
+         * // Prints: javascript
+         * console.log(String(myMIME));
+         * // Prints: text/javascript
+         * ```
          */
         subtype: string;
         /**
-         * Gets the essence of the MIME.
-         *
+         * Gets the essence of the MIME. This property is read only.
          * Use `mime.type` or `mime.subtype` to alter the MIME.
+         *
+         * ```js
+         * import { MIMEType } from 'node:util';
+         *
+         * const myMIME = new MIMEType('text/javascript;key=value');
+         * console.log(myMIME.essence);
+         * // Prints: text/javascript
+         * myMIME.type = 'application';
+         * console.log(myMIME.essence);
+         * // Prints: application/javascript
+         * console.log(String(myMIME));
+         * // Prints: application/javascript;key=value
+         * ```
          */
         readonly essence: string;
         /**
-         * Gets the `MIMEParams` object representing the parameters of the MIME.
+         * Gets the `MIMEParams` object representing the
+         * parameters of the MIME. This property is read-only. See `MIMEParams` documentation for details.
          */
         readonly params: MIMEParams;
         /**
-         * Returns the serialized MIME.
+         * The `toString()` method on the `MIMEType` object returns the serialized MIME.
          *
-         * Because of the need for standard compliance, this method
-         * does not allow users to customize the serialization process of the MIME.
+         * Because of the need for standard compliance, this method does not allow users
+         * to customize the serialization process of the MIME.
          */
         toString(): string;
     }
     /**
-     * @since v18.13.0
+     * The `MIMEParams` API provides read and write access to the parameters of a`MIMEType`.
+     * @since v19.1.0, v18.13.0
      */
     export class MIMEParams {
         /**
@@ -1494,11 +1534,14 @@ declare module 'util' {
         delete(name: string): void;
         /**
          * Returns an iterator over each of the name-value pairs in the parameters.
+         * Each item of the iterator is a JavaScript `Array`. The first item of the array
+         * is the `name`, the second item of the array is the `value`.
          */
         entries(): IterableIterator<[name: string, value: string]>;
         /**
-         * Returns the value of the first name-value pair whose name is `name`.
-         * If there are no such pairs, `null` is returned.
+         * Returns the value of the first name-value pair whose name is `name`. If there
+         * are no such pairs, `null` is returned.
+         * @return or `null` if there is no name-value pair with the given `name`.
          */
         get(name: string): string | null;
         /**
@@ -1507,12 +1550,33 @@ declare module 'util' {
         has(name: string): boolean;
         /**
          * Returns an iterator over the names of each name-value pair.
+         *
+         * ```js
+         * import { MIMEType } from 'node:util';
+         *
+         * const { params } = new MIMEType('text/plain;foo=0;bar=1');
+         * for (const name of params.keys()) {
+         *   console.log(name);
+         * }
+         * // Prints:
+         * //   foo
+         * //   bar
+         * ```
          */
         keys(): IterableIterator<string>;
         /**
-         * Sets the value in the `MIMEParams` object associated with `name` to `value`.
-         * If there are any pre-existing name-value pairs whose names are `name`,
+         * Sets the value in the `MIMEParams` object associated with `name` to`value`. If there are any pre-existing name-value pairs whose names are `name`,
          * set the first such pair's value to `value`.
+         *
+         * ```js
+         * import { MIMEType } from 'node:util';
+         *
+         * const { params } = new MIMEType('text/plain;foo=0;bar=1');
+         * params.set('foo', 'def');
+         * params.set('baz', 'xyz');
+         * console.log(params.toString());
+         * // Prints: foo=def&#x26;bar=1&#x26;baz=xyz
+         * ```
          */
         set(name: string, value: string): void;
         /**