@types/node 20.12.7 → 20.12.9

node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Tue, 09 Apr 2024 21:07:24 GMT
+ * Last updated: Mon, 06 May 2024 14:07:34 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

node/assert.d.ts

@@ -1,7 +1,7 @@
 /**
  * The `node:assert` module provides a set of assertion functions for verifying
  * invariants.
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/assert.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/assert.js)
  */
 declare module "assert" {
     /**
@@ -12,7 +12,7 @@ declare module "assert" {
     function assert(value: unknown, message?: string | Error): asserts value;
     namespace assert {
         /**
-         * Indicates the failure of an assertion. All errors thrown by the `node:assert`module will be instances of the `AssertionError` class.
+         * Indicates the failure of an assertion. All errors thrown by the `node:assert` module will be instances of the `AssertionError` class.
          */
         class AssertionError extends Error {
             /**
@@ -76,7 +76,7 @@ declare module "assert" {
              * @since v14.2.0, v12.19.0
              * @param [fn='A no-op function']
              * @param [exact=1]
-             * @return that wraps `fn`.
+             * @return A function that wraps `fn`.
              */
             calls(exact?: number): () => void;
             calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func;
@@ -96,8 +96,7 @@ declare module "assert" {
              *                        [{ thisArg: undefined, arguments: [1, 2, 3] }]);
              * ```
              * @since v18.8.0, v16.18.0
-             * @param fn
-             * @return An Array with all the calls to a tracked function.
+             * @return An array with all the calls to a tracked function.
              */
             getCalls(fn: Function): CallTrackerCall[];
             /**
@@ -130,12 +129,11 @@ declare module "assert" {
              * // ]
              * ```
              * @since v14.2.0, v12.19.0
-             * @return An Array of objects containing information about the wrapper functions returned by `calls`.
+             * @return An array of objects containing information about the wrapper functions returned by {@link tracker.calls()}.
              */
             report(): CallTrackerReportInformation[];
             /**
-             * Reset calls of the call tracker.
-             * If a tracked function is passed as an argument, the calls will be reset for it.
+             * Reset calls of the call tracker. If a tracked function is passed as an argument, the calls will be reset for it.
              * If no arguments are passed, all tracked functions will be reset.
              *
              * ```js
@@ -158,7 +156,7 @@ declare module "assert" {
              */
             reset(fn?: Function): void;
             /**
-             * Iterates through the list of functions passed to `tracker.calls()` and will throw an error for functions that
+             * Iterates through the list of functions passed to {@link tracker.calls()} and will throw an error for functions that
              * have not been called the expected number of times.
              *
              * ```js
@@ -232,10 +230,10 @@ declare module "assert" {
             stackStartFn?: Function,
         ): never;
         /**
-         * Tests if `value` is truthy. It is equivalent to`assert.equal(!!value, true, message)`.
+         * Tests if `value` is truthy. It is equivalent to `assert.equal(!!value, true, message)`.
          *
-         * If `value` is not truthy, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is `undefined`, a default
-         * error message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.
+         * If `value` is not truthy, an `AssertionError` is thrown with a `message` property set equal to the value of the `message` parameter. If the `message` parameter is `undefined`, a default
+         * error message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown instead of the `AssertionError`.
          * If no arguments are passed in at all `message` will be set to the string:`` 'No value argument passed to `assert.ok()`' ``.
          *
          * Be aware that in the `repl` the error message will be different to the one
@@ -317,8 +315,8 @@ declare module "assert" {
          * // AssertionError: { a: { b: 1 } } == { a: { b: 1 } }
          * ```
          *
-         * If the values are not equal, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is undefined, a default
-         * error message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.
+         * If the values are not equal, an `AssertionError` is thrown with a `message` property set equal to the value of the `message` parameter. If the `message` parameter is undefined, a default
+         * error message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown instead of the `AssertionError`.
          * @since v0.1.21
          */
         function equal(actual: unknown, expected: unknown, message?: string | Error): void;
@@ -347,8 +345,8 @@ declare module "assert" {
          * // AssertionError: 1 != '1'
          * ```
          *
-         * If the values are equal, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is undefined, a default error
-         * message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.
+         * If the values are equal, an `AssertionError` is thrown with a `message` property set equal to the value of the `message` parameter. If the `message` parameter is undefined, a default error
+         * message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown instead of the `AssertionError`.
          * @since v0.1.21
          */
         function notEqual(actual: unknown, expected: unknown, message?: string | Error): void;
@@ -414,8 +412,8 @@ declare module "assert" {
          * // OK
          * ```
          *
-         * If the values are deeply equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a default
-         * error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown
+         * If the values are deeply equal, an `AssertionError` is thrown with a `message` property set equal to the value of the `message` parameter. If the `message` parameter is undefined, a default
+         * error message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown
          * instead of the `AssertionError`.
          * @since v0.1.21
          */
@@ -452,8 +450,8 @@ declare module "assert" {
          * // TypeError: Inputs are not identical
          * ```
          *
-         * If the values are not strictly equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a
-         * default error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown
+         * If the values are not strictly equal, an `AssertionError` is thrown with a `message` property set equal to the value of the `message` parameter. If the `message` parameter is undefined, a
+         * default error message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown
          * instead of the `AssertionError`.
          * @since v0.1.21
          */
@@ -477,8 +475,8 @@ declare module "assert" {
          * // OK
          * ```
          *
-         * If the values are strictly equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a
-         * default error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown
+         * If the values are strictly equal, an `AssertionError` is thrown with a `message` property set equal to the value of the `message` parameter. If the `message` parameter is undefined, a
+         * default error message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown
          * instead of the `AssertionError`.
          * @since v0.1.21
          */
@@ -519,7 +517,7 @@ declare module "assert" {
          * using an object, it is also possible to use a regular expression, when
          * validating against a string property. See below for examples.
          *
-         * If specified, `message` will be appended to the message provided by the`AssertionError` if the `fn` call fails to throw or in case the error validation
+         * If specified, `message` will be appended to the message provided by the `AssertionError` if the `fn` call fails to throw or in case the error validation
          * fails.
          *
          * Custom validation object/error instance:
@@ -649,8 +647,8 @@ declare module "assert" {
          * ```
          *
          * `error` cannot be a string. If a string is provided as the second
-         * argument, then `error` is assumed to be omitted and the string will be used for`message` instead. This can lead to easy-to-miss mistakes. Using the same
-         * message as the thrown error message is going to result in an`ERR_AMBIGUOUS_ARGUMENT` error. Please read the example below carefully if using
+         * argument, then `error` is assumed to be omitted and the string will be used for `message` instead. This can lead to easy-to-miss mistakes. Using the same
+         * message as the thrown error message is going to result in an `ERR_AMBIGUOUS_ARGUMENT` error. Please read the example below carefully if using
          * a string as the second argument gets considered:
          *
          * ```js
@@ -703,9 +701,9 @@ declare module "assert" {
          * adding a comment next to the specific code path that should not throw and keep
          * error messages as expressive as possible.
          *
-         * When `assert.doesNotThrow()` is called, it will immediately call the `fn`function.
+         * When `assert.doesNotThrow()` is called, it will immediately call the `fn` function.
          *
-         * If an error is thrown and it is the same type as that specified by the `error`parameter, then an `AssertionError` is thrown. If the error is of a
+         * If an error is thrown and it is the same type as that specified by the `error` parameter, then an `AssertionError` is thrown. If the error is of a
          * different type, or if the `error` parameter is undefined, the error is
          * propagated back to the caller.
          *
@@ -741,7 +739,7 @@ declare module "assert" {
          * );
          * ```
          *
-         * If an `AssertionError` is thrown and a value is provided for the `message`parameter, the value of `message` will be appended to the `AssertionError` message:
+         * If an `AssertionError` is thrown and a value is provided for the `message` parameter, the value of `message` will be appended to the `AssertionError` message:
          *
          * ```js
          * import assert from 'node:assert/strict';
@@ -762,7 +760,7 @@ declare module "assert" {
         /**
          * Throws `value` if `value` is not `undefined` or `null`. This is useful when
          * testing the `error` argument in callbacks. The stack trace contains all frames
-         * from the error passed to `ifError()` including the potential new frames for`ifError()` itself.
+         * from the error passed to `ifError()` including the potential new frames for `ifError()` itself.
          *
          * ```js
          * import assert from 'node:assert/strict';
@@ -797,18 +795,18 @@ declare module "assert" {
          * calls the function and awaits the returned promise to complete. It will then
          * check that the promise is rejected.
          *
-         * If `asyncFn` is a function and it throws an error synchronously,`assert.rejects()` will return a rejected `Promise` with that error. If the
-         * function does not return a promise, `assert.rejects()` will return a rejected`Promise` with an `ERR_INVALID_RETURN_VALUE` error. In both cases the error
-         * handler is skipped.
+         * If `asyncFn` is a function and it throws an error synchronously, `assert.rejects()` will return a rejected `Promise` with that error. If the
+         * function does not return a promise, `assert.rejects()` will return a rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v20.x/api/errors.html#err_invalid_return_value)
+         * error. In both cases the error handler is skipped.
          *
          * Besides the async nature to await the completion behaves identically to {@link throws}.
          *
          * If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
          * [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), a validation function,
          * an object where each property will be tested for, or an instance of error where
-         * each property will be tested for including the non-enumerable `message` and`name` properties.
+         * each property will be tested for including the non-enumerable `message` and `name` properties.
          *
-         * If specified, `message` will be the message provided by the `AssertionError` if the `asyncFn` fails to reject.
+         * If specified, `message` will be the message provided by the `{@link AssertionError}` if the `asyncFn` fails to reject.
          *
          * ```js
          * import assert from 'node:assert/strict';
@@ -850,10 +848,9 @@ declare module "assert" {
          * });
          * ```
          *
-         * `error` cannot be a string. If a string is provided as the second
-         * argument, then `error` is assumed to be omitted and the string will be used for`message` instead. This can lead to easy-to-miss mistakes. Please read the
-         * example in {@link throws} carefully if using a string as the second
-         * argument gets considered.
+         * `error` cannot be a string. If a string is provided as the second argument, then `error` is assumed to
+         * be omitted and the string will be used for `message` instead. This can lead to easy-to-miss mistakes. Please read the
+         * example in {@link throws} carefully if using a string as the second argument gets considered.
          * @since v10.0.0
          */
         function rejects(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
@@ -867,9 +864,9 @@ declare module "assert" {
          * calls the function and awaits the returned promise to complete. It will then
          * check that the promise is not rejected.
          *
-         * If `asyncFn` is a function and it throws an error synchronously,`assert.doesNotReject()` will return a rejected `Promise` with that error. If
+         * If `asyncFn` is a function and it throws an error synchronously, `assert.doesNotReject()` will return a rejected `Promise` with that error. If
          * the function does not return a promise, `assert.doesNotReject()` will return a
-         * rejected `Promise` with an `ERR_INVALID_RETURN_VALUE` error. In both cases
+         * rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v20.x/api/errors.html#err_invalid_return_value) error. In both cases
          * the error handler is skipped.
          *
          * Using `assert.doesNotReject()` is actually not useful because there is little
@@ -929,10 +926,10 @@ declare module "assert" {
          * // OK
          * ```
          *
-         * If the values do not match, or if the `string` argument is of another type than`string`, an `AssertionError` is thrown with a `message` property set equal
+         * If the values do not match, or if the `string` argument is of another type than `string`, an `{@link AssertionError}` is thrown with a `message` property set equal
          * to the value of the `message` parameter. If the `message` parameter is
          * undefined, a default error message is assigned. If the `message` parameter is an
-         * instance of an `Error` then it will be thrown instead of the `AssertionError`.
+         * instance of an [Error](https://nodejs.org/docs/latest-v20.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
          * @since v13.6.0, v12.16.0
          */
         function match(value: string, regExp: RegExp, message?: string | Error): void;
@@ -952,10 +949,10 @@ declare module "assert" {
          * // OK
          * ```
          *
-         * If the values do match, or if the `string` argument is of another type than`string`, an `AssertionError` is thrown with a `message` property set equal
+         * If the values do match, or if the `string` argument is of another type than `string`, an `{@link AssertionError}` is thrown with a `message` property set equal
          * to the value of the `message` parameter. If the `message` parameter is
          * undefined, a default error message is assigned. If the `message` parameter is an
-         * instance of an `Error` then it will be thrown instead of the `AssertionError`.
+         * instance of an [Error](https://nodejs.org/docs/latest-v20.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
          * @since v13.6.0, v12.16.0
          */
         function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;

node/async_hooks.d.ts

@@ -2,8 +2,8 @@
  * We strongly discourage the use of the `async_hooks` API.
  * Other APIs that can cover most of its use cases include:
  *
- * * `AsyncLocalStorage` tracks async context
- * * `process.getActiveResourcesInfo()` tracks active resources
+ * * [`AsyncLocalStorage`](https://nodejs.org/docs/latest-v20.x/api/async_context.html#class-asynclocalstorage) tracks async context
+ * * [`process.getActiveResourcesInfo()`](https://nodejs.org/docs/latest-v20.x/api/process.html#processgetactiveresourcesinfo) tracks active resources
  *
  * The `node:async_hooks` module provides an API to track asynchronous resources.
  * It can be accessed using:
@@ -12,7 +12,7 @@
  * import async_hooks from 'node:async_hooks';
  * ```
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/async_hooks.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/async_hooks.js)
  */
 declare module "async_hooks" {
     /**
@@ -44,7 +44,7 @@ declare module "async_hooks" {
      * ```
      *
      * Promise contexts may not get precise `executionAsyncIds` by default.
-     * See the section on `promise execution tracking`.
+     * See the section on [promise execution tracking](https://nodejs.org/docs/latest-v20.x/api/async_hooks.html#promise-execution-tracking).
      * @since v8.1.0
      * @return The `asyncId` of the current execution context. Useful to track when something calls.
      */
@@ -117,17 +117,17 @@ declare module "async_hooks" {
      * ```
      *
      * Promise contexts may not get valid `triggerAsyncId`s by default. See
-     * the section on `promise execution tracking`.
+     * the section on [promise execution tracking](https://nodejs.org/docs/latest-v20.x/api/async_hooks.html#promise-execution-tracking).
      * @return The ID of the resource responsible for calling the callback that is currently being executed.
      */
     function triggerAsyncId(): number;
     interface HookCallbacks {
         /**
          * Called when a class is constructed that has the possibility to emit an asynchronous event.
-         * @param asyncId a unique ID for the async resource
-         * @param type the type of the async resource
-         * @param triggerAsyncId the unique ID of the async resource in whose execution context this async resource was created
-         * @param resource reference to the resource representing the async operation, needs to be released during destroy
+         * @param asyncId A unique ID for the async resource
+         * @param type The type of the async resource
+         * @param triggerAsyncId The unique ID of the async resource in whose execution context this async resource was created
+         * @param resource Reference to the resource representing the async operation, needs to be released during destroy
          */
         init?(asyncId: number, type: string, triggerAsyncId: number, resource: object): void;
         /**
@@ -137,7 +137,9 @@ declare module "async_hooks" {
          */
         before?(asyncId: number): void;
         /**
-         * Called immediately after the callback specified in before is completed.
+         * Called immediately after the callback specified in `before` is completed.
+         *
+         * If an uncaught exception occurs during execution of the callback, then `after` will run after the `'uncaughtException'` event is emitted or a `domain`'s handler runs.
          * @param asyncId the unique identifier assigned to the resource which has executed the callback.
          */
         after?(asyncId: number): void;
@@ -321,7 +323,7 @@ declare module "async_hooks" {
     /**
      * This class creates stores that stay coherent through asynchronous operations.
      *
-     * While you can create your own implementation on top of the `node:async_hooks`module, `AsyncLocalStorage` should be preferred as it is a performant and memory
+     * While you can create your own implementation on top of the `node:async_hooks` module, `AsyncLocalStorage` should be preferred as it is a performant and memory
      * safe implementation that involves significant optimizations that are non-obvious
      * to implement.
      *
@@ -407,12 +409,12 @@ declare module "async_hooks" {
         static snapshot(): <R, TArgs extends any[]>(fn: (...args: TArgs) => R, ...args: TArgs) => R;
         /**
          * Disables the instance of `AsyncLocalStorage`. All subsequent calls
-         * to `asyncLocalStorage.getStore()` will return `undefined` until`asyncLocalStorage.run()` or `asyncLocalStorage.enterWith()` is called again.
+         * to `asyncLocalStorage.getStore()` will return `undefined` until `asyncLocalStorage.run()` or `asyncLocalStorage.enterWith()` is called again.
          *
          * When calling `asyncLocalStorage.disable()`, all current contexts linked to the
          * instance will be exited.
          *
-         * Calling `asyncLocalStorage.disable()` is required before the`asyncLocalStorage` can be garbage collected. This does not apply to stores
+         * Calling `asyncLocalStorage.disable()` is required before the `asyncLocalStorage` can be garbage collected. This does not apply to stores
          * provided by the `asyncLocalStorage`, as those objects are garbage collected
          * along with the corresponding async resources.
          *
@@ -465,7 +467,7 @@ declare module "async_hooks" {
         /**
          * Runs a function synchronously outside of a context and returns its
          * return value. The store is not accessible within the callback function or
-         * the asynchronous operations created within the callback. Any `getStore()`call done within the callback function will always return `undefined`.
+         * the asynchronous operations created within the callback. Any `getStore()` call done within the callback function will always return `undefined`.
          *
          * The optional `args` are passed to the callback function.
          *
@@ -511,7 +513,7 @@ declare module "async_hooks" {
          * This transition will continue for the _entire_ synchronous execution.
          * This means that if, for example, the context is entered within an event
          * handler subsequent event handlers will also run within that context unless
-         * specifically bound to another context with an `AsyncResource`. That is why`run()` should be preferred over `enterWith()` unless there are strong reasons
+         * specifically bound to another context with an `AsyncResource`. That is why `run()` should be preferred over `enterWith()` unless there are strong reasons
          * to use the latter method.
          *
          * ```js

node/buffer.d.ts

@@ -41,7 +41,7 @@
  * // Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].
  * const buf7 = Buffer.from('tést', 'latin1');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/buffer.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/buffer.js)
  */
 declare module "buffer" {
     import { BinaryLike } from "node:crypto";
@@ -311,12 +311,12 @@ declare module "buffer" {
              *
              * If `array` is an `Array`\-like object (that is, one with a `length` property of
              * type `number`), it is treated as if it is an array, unless it is a `Buffer` or
-             * a `Uint8Array`. This means all other `TypedArray` variants get treated as an`Array`. To create a `Buffer` from the bytes backing a `TypedArray`, use `Buffer.copyBytesFrom()`.
+             * a `Uint8Array`. This means all other `TypedArray` variants get treated as an `Array`. To create a `Buffer` from the bytes backing a `TypedArray`, use `Buffer.copyBytesFrom()`.
              *
              * A `TypeError` will be thrown if `array` is not an `Array` or another type
              * appropriate for `Buffer.from()` variants.
              *
-             * `Buffer.from(array)` and `Buffer.from(string)` may also use the internal`Buffer` pool like `Buffer.allocUnsafe()` does.
+             * `Buffer.from(array)` and `Buffer.from(string)` may also use the internal `Buffer` pool like `Buffer.allocUnsafe()` does.
              * @since v5.10.0
              */
             from(
@@ -420,9 +420,9 @@ declare module "buffer" {
                 encoding?: BufferEncoding,
             ): number;
             /**
-             * Returns a new `Buffer` which is the result of concatenating all the `Buffer`instances in the `list` together.
+             * Returns a new `Buffer` which is the result of concatenating all the `Buffer` instances in the `list` together.
              *
-             * If the list has no items, or if the `totalLength` is 0, then a new zero-length`Buffer` is returned.
+             * If the list has no items, or if the `totalLength` is 0, then a new zero-length `Buffer` is returned.
              *
              * If `totalLength` is not provided, it is calculated from the `Buffer` instances
              * in `list` by adding their lengths.
@@ -476,7 +476,7 @@ declare module "buffer" {
              */
             copyBytesFrom(view: NodeJS.TypedArray, offset?: number, length?: number): Buffer;
             /**
-             * Compares `buf1` to `buf2`, typically for the purpose of sorting arrays of`Buffer` instances. This is equivalent to calling `buf1.compare(buf2)`.
+             * Compares `buf1` to `buf2`, typically for the purpose of sorting arrays of `Buffer` instances. This is equivalent to calling `buf1.compare(buf2)`.
              *
              * ```js
              * import { Buffer } from 'node:buffer';
@@ -2098,7 +2098,7 @@ declare module "buffer" {
              * // Prints: 6
              * ```
              *
-             * If `value` is not a string, number, or `Buffer`, this method will throw a`TypeError`. If `value` is a number, it will be coerced to a valid byte value,
+             * If `value` is not a string, number, or `Buffer`, this method will throw a `TypeError`. If `value` is a number, it will be coerced to a valid byte value,
              * an integer between 0 and 255.
              *
              * If `byteOffset` is not a number, it will be coerced to a number. If the result

node/child_process.d.ts

@@ -63,7 +63,7 @@
  * For certain use cases, such as automating shell scripts, the `synchronous counterparts` may be more convenient. In many cases, however,
  * the synchronous methods can have significant impact on performance due to
  * stalling the event loop while spawned processes complete.
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/child_process.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/child_process.js)
  */
 declare module "child_process" {
     import { ObjectEncodingOptions } from "node:fs";

node/cluster.d.ts

@@ -50,7 +50,7 @@
  * ```
  *
  * On Windows, it is not yet possible to set up a named pipe server in a worker.
- * @see [source](https://github.com/nodejs/node/blob/v20.11.1/lib/cluster.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/cluster.js)
  */
 declare module "cluster" {
     import * as child from "node:child_process";

node/console.d.ts

@@ -54,7 +54,7 @@
  * myConsole.warn(`Danger ${name}! Danger!`);
  * // Prints: Danger Will Robinson! Danger!, to err
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.12.1/lib/console.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/console.js)
  */
 declare module "console" {
     import console = require("node:console");

node/crypto.d.ts

@@ -14,7 +14,7 @@
  * // Prints:
  * //   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/crypto.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/crypto.js)
  */
 declare module "crypto" {
     import * as stream from "node:stream";
@@ -27,7 +27,7 @@ declare module "crypto" {
      * should not use this element anymore.
      *
      * The `node:crypto` module provides the `Certificate` class for working with SPKAC
-     * data. The most common usage is handling output generated by the HTML5`<keygen>` element. Node.js uses [OpenSSL's SPKAC
+     * data. The most common usage is handling output generated by the HTML5 `<keygen>` element. Node.js uses [OpenSSL's SPKAC
      * implementation](https://www.openssl.org/docs/man3.0/man1/openssl-spkac.html) internally.
      * @since v0.11.8
      */
@@ -3344,7 +3344,7 @@ declare module "crypto" {
         callback: (error: Error | null, data: Buffer) => void,
     ): void;
     /**
-     * Verifies the given signature for `data` using the given key and algorithm. If`algorithm` is `null` or `undefined`, then the algorithm is dependent upon the
+     * Verifies the given signature for `data` using the given key and algorithm. If `algorithm` is `null` or `undefined`, then the algorithm is dependent upon the
      * key type (especially Ed25519 and Ed448).
      *
      * If `key` is not a `KeyObject`, this function behaves as if `key` had been
@@ -3378,6 +3378,41 @@ declare module "crypto" {
      * @since v13.9.0, v12.17.0
      */
     function diffieHellman(options: { privateKey: KeyObject; publicKey: KeyObject }): Buffer;
+    /**
+     * A utility for creating one-shot hash digests of data. It can be faster than the object-based `crypto.createHash()` when hashing a smaller amount of data
+     * (<= 5MB) that's readily available. If the data can be big or if it is streamed, it's still recommended to use `crypto.createHash()` instead. The `algorithm`
+     * is dependent on the available algorithms supported by the version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc. On recent releases
+     * of OpenSSL, `openssl list -digest-algorithms` will display the available digest algorithms.
+     *
+     * Example:
+     *
+     * ```js
+     * const crypto = require('node:crypto');
+     * const { Buffer } = require('node:buffer');
+     *
+     * // Hashing a string and return the result as a hex-encoded string.
+     * const string = 'Node.js';
+     * // 10b3493287f831e81a438811a1ffba01f8cec4b7
+     * console.log(crypto.hash('sha1', string));
+     *
+     * // Encode a base64-encoded string into a Buffer, hash it and return
+     * // the result as a buffer.
+     * const base64 = 'Tm9kZS5qcw==';
+     * // <Buffer 10 b3 49 32 87 f8 31 e8 1a 43 88 11 a1 ff ba 01 f8 ce c4 b7>
+     * console.log(crypto.hash('sha1', Buffer.from(base64, 'base64'), 'buffer'));
+     * ```
+     * @since v21.7.0, v20.12.0
+     * @param data When `data` is a string, it will be encoded as UTF-8 before being hashed. If a different input encoding is desired for a string input, user
+     *             could encode the string into a `TypedArray` using either `TextEncoder` or `Buffer.from()` and passing the encoded `TypedArray` into this API instead.
+     * @param [outputEncoding='hex'] [Encoding](https://nodejs.org/docs/latest-v20.x/api/buffer.html#buffers-and-character-encodings) used to encode the returned digest.
+     */
+    function hash(algorithm: string, data: BinaryLike, outputEncoding?: BinaryToTextEncoding): string;
+    function hash(algorithm: string, data: BinaryLike, outputEncoding: "buffer"): Buffer;
+    function hash(
+        algorithm: string,
+        data: BinaryLike,
+        outputEncoding?: BinaryToTextEncoding | "buffer",
+    ): string | Buffer;
     type CipherMode = "cbc" | "ccm" | "cfb" | "ctr" | "ecb" | "gcm" | "ocb" | "ofb" | "stream" | "wrap" | "xts";
     interface CipherInfoOptions {
         /**

node/dgram.d.ts

@@ -23,7 +23,7 @@
  * server.bind(41234);
  * // Prints: server listening 0.0.0.0:41234
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/dgram.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/dgram.js)
  */
 declare module "dgram" {
     import { AddressInfo } from "node:net";
@@ -66,7 +66,7 @@ declare module "dgram" {
      * (it does the right thing for both `udp4` and `udp6` sockets). The bound address
      * and port can be retrieved using `socket.address().address` and `socket.address().port`.
      *
-     * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.close()` on the socket:
+     * If the `signal` option is enabled, calling `.abort()` on the corresponding `AbortController` is similar to calling `.close()` on the socket:
      *
      * ```js
      * const controller = new AbortController();
@@ -93,7 +93,7 @@ declare module "dgram" {
      */
     class Socket extends EventEmitter {
         /**
-         * Tells the kernel to join a multicast group at the given `multicastAddress` and`multicastInterface` using the `IP_ADD_MEMBERSHIP` socket option. If the`multicastInterface` argument is not
+         * Tells the kernel to join a multicast group at the given `multicastAddress` and `multicastInterface` using the `IP_ADD_MEMBERSHIP` socket option. If the `multicastInterface` argument is not
          * specified, the operating system will choose
          * one interface and will add membership to it. To add membership to every
          * available interface, call `addMembership` multiple times, once per interface.
@@ -122,7 +122,7 @@ declare module "dgram" {
         addMembership(multicastAddress: string, multicastInterface?: string): void;
         /**
          * Returns an object containing the address information for a socket.
-         * For UDP sockets, this object will contain `address`, `family`, and `port`properties.
+         * For UDP sockets, this object will contain `address`, `family`, and `port` properties.
          *
          * This method throws `EBADF` if called on an unbound socket.
          * @since v0.1.99
@@ -133,10 +133,10 @@ declare module "dgram" {
          * messages on a named `port` and optional `address`. If `port` is not
          * specified or is `0`, the operating system will attempt to bind to a
          * random port. If `address` is not specified, the operating system will
-         * attempt to listen on all addresses. Once binding is complete, a`'listening'` event is emitted and the optional `callback` function is
+         * attempt to listen on all addresses. Once binding is complete, a `'listening'` event is emitted and the optional `callback` function is
          * called.
          *
-         * Specifying both a `'listening'` event listener and passing a`callback` to the `socket.bind()` method is not harmful but not very
+         * Specifying both a `'listening'` event listener and passing a `callback` to the `socket.bind()` method is not harmful but not very
          * useful.
          *
          * A bound datagram socket keeps the Node.js process running to receive
@@ -206,7 +206,7 @@ declare module "dgram" {
          */
         disconnect(): void;
         /**
-         * Instructs the kernel to leave a multicast group at `multicastAddress` using the`IP_DROP_MEMBERSHIP` socket option. This method is automatically called by the
+         * Instructs the kernel to leave a multicast group at `multicastAddress` using the `IP_DROP_MEMBERSHIP` socket option. This method is automatically called by the
          * kernel when the socket is closed or the process terminates, so most apps will
          * never have reason to call this.
          *
@@ -269,7 +269,7 @@ declare module "dgram" {
          * any `TypedArray` or a `DataView`,
          * the `offset` and `length` specify the offset within the `Buffer` where the
          * message begins and the number of bytes in the message, respectively.
-         * If `msg` is a `String`, then it is automatically converted to a `Buffer`with `'utf8'` encoding. With messages that
+         * If `msg` is a `String`, then it is automatically converted to a `Buffer` with `'utf8'` encoding. With messages that
          * contain multi-byte characters, `offset` and `length` will be calculated with
          * respect to `byte length` and not the character position.
          * If `msg` is an array, `offset` and `length` must not be specified.
@@ -287,7 +287,7 @@ declare module "dgram" {
          * DNS lookups delay the time to send for at least one tick of the
          * Node.js event loop.
          *
-         * The only way to know for sure that the datagram has been sent is by using a`callback`. If an error occurs and a `callback` is given, the error will be
+         * The only way to know for sure that the datagram has been sent is by using a `callback`. If an error occurs and a `callback` is given, the error will be
          * passed as the first argument to the `callback`. If a `callback` is not given,
          * the error is emitted as an `'error'` event on the `socket` object.
          *
@@ -329,7 +329,7 @@ declare module "dgram" {
          * determine the optimal strategy on a case-by-case basis. Generally speaking,
          * however, sending multiple buffers is faster.
          *
-         * Example of sending a UDP packet using a socket connected to a port on`localhost`:
+         * Example of sending a UDP packet using a socket connected to a port on `localhost`:
          *
          * ```js
          * import dgram from 'node:dgram';
@@ -519,10 +519,10 @@ declare module "dgram" {
          */
         unref(): this;
         /**
-         * Tells the kernel to join a source-specific multicast channel at the given`sourceAddress` and `groupAddress`, using the `multicastInterface` with the`IP_ADD_SOURCE_MEMBERSHIP` socket
+         * Tells the kernel to join a source-specific multicast channel at the given `sourceAddress` and `groupAddress`, using the `multicastInterface` with the `IP_ADD_SOURCE_MEMBERSHIP` socket
          * option. If the `multicastInterface` argument
          * is not specified, the operating system will choose one interface and will add
-         * membership to it. To add membership to every available interface, call`socket.addSourceSpecificMembership()` multiple times, once per interface.
+         * membership to it. To add membership to every available interface, call `socket.addSourceSpecificMembership()` multiple times, once per interface.
          *
          * When called on an unbound socket, this method will implicitly bind to a random
          * port, listening on all interfaces.
@@ -530,7 +530,7 @@ declare module "dgram" {
          */
         addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
         /**
-         * Instructs the kernel to leave a source-specific multicast channel at the given`sourceAddress` and `groupAddress` using the `IP_DROP_SOURCE_MEMBERSHIP`socket option. This method is
+         * Instructs the kernel to leave a source-specific multicast channel at the given `sourceAddress` and `groupAddress` using the `IP_DROP_SOURCE_MEMBERSHIP` socket option. This method is
          * automatically called by the kernel when the
          * socket is closed or the process terminates, so most apps will never have
          * reason to call this.