@types/node 20.12.13 → 20.12.14

node/perf_hooks.d.ts

@@ -27,7 +27,7 @@
  *   performance.measure('A to B', 'A', 'B');
  * });
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/perf_hooks.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/perf_hooks.js)
  */
 declare module "perf_hooks" {
     import { AsyncResource } from "node:async_hooks";
@@ -150,11 +150,6 @@ declare module "perf_hooks" {
          * @since v8.5.0
          */
         readonly loopStart: number;
-        /**
-         * The high resolution millisecond timestamp at which the Node.js process was initialized.
-         * @since v8.5.0
-         */
-        readonly nodeStart: number;
         /**
          * The high resolution millisecond timestamp at which the V8 platform was
          * initialized.
@@ -168,12 +163,12 @@ declare module "perf_hooks" {
         utilization: number;
     }
     /**
-     * @param utilization1 The result of a previous call to `eventLoopUtilization()`.
-     * @param utilization2 The result of a previous call to `eventLoopUtilization()` prior to `utilization1`.
+     * @param util1 The result of a previous call to eventLoopUtilization()
+     * @param util2 The result of a previous call to eventLoopUtilization() prior to util1
      */
     type EventLoopUtilityFunction = (
-        utilization1?: EventLoopUtilization,
-        utilization2?: EventLoopUtilization,
+        util1?: EventLoopUtilization,
+        util2?: EventLoopUtilization,
     ) => EventLoopUtilization;
     interface MarkOptions {
         /**
@@ -182,7 +177,7 @@ declare module "perf_hooks" {
         detail?: unknown | undefined;
         /**
          * An optional timestamp to be used as the mark time.
-         * @default `performance.now()`
+         * @default `performance.now()`.
          */
         startTime?: number | undefined;
     }
@@ -206,36 +201,26 @@ declare module "perf_hooks" {
     }
     interface TimerifyOptions {
         /**
-         * A histogram object created using `perf_hooks.createHistogram()` that will record runtime
-         * durations in nanoseconds.
+         * A histogram object created using
+         * `perf_hooks.createHistogram()` that will record runtime durations in
+         * nanoseconds.
          */
         histogram?: RecordableHistogram | undefined;
     }
     interface Performance {
         /**
-         * If `name` is not provided, removes all `PerformanceMark` objects from the Performance Timeline.
-         * If `name` is provided, removes only the named mark.
-         * @since v8.5.0
+         * If name is not provided, removes all PerformanceMark objects from the Performance Timeline.
+         * If name is provided, removes only the named mark.
+         * @param name
          */
         clearMarks(name?: string): void;
         /**
-         * If `name` is not provided, removes all `PerformanceMeasure` objects from the Performance Timeline.
-         * If `name` is provided, removes only the named measure.
+         * If name is not provided, removes all PerformanceMeasure objects from the Performance Timeline.
+         * If name is provided, removes only the named measure.
+         * @param name
          * @since v16.7.0
          */
         clearMeasures(name?: string): void;
-        /**
-         * If `name` is not provided, removes all `PerformanceResourceTiming` objects from the Resource Timeline.
-         * If `name` is provided, removes only the named resource.
-         * @since v18.2.0, v16.17.0
-         */
-        clearResourceTimings(name?: string): void;
-        /**
-         * eventLoopUtilization is similar to CPU utilization except that it is calculated using high precision wall-clock time.
-         * It represents the percentage of time the event loop has spent outside the event loop's event provider (e.g. epoll_wait).
-         * No other CPU idle time is taken into consideration.
-         */
-        eventLoopUtilization: EventLoopUtilityFunction;
         /**
          * Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`.
          * If you are only interested in performance entries of certain types or that have certain names, see
@@ -259,17 +244,14 @@ declare module "perf_hooks" {
          */
         getEntriesByType(type: EntryType): PerformanceEntry[];
         /**
-         * Creates a new `PerformanceMark` entry in the Performance Timeline.
-         * A `PerformanceMark` is a subclass of `PerformanceEntry` whose `performanceEntry.entryType` is always `'mark'`,
-         * and whose `performanceEntry.duration` is always `0`.
+         * Creates a new PerformanceMark entry in the Performance Timeline.
+         * A PerformanceMark is a subclass of PerformanceEntry whose performanceEntry.entryType is always 'mark',
+         * and whose performanceEntry.duration is always 0.
          * Performance marks are used to mark specific significant moments in the Performance Timeline.
-         *
-         * The created `PerformanceMark` entry is put in the global Performance Timeline and can be queried with
-         * `performance.getEntries`, `performance.getEntriesByName`, and `performance.getEntriesByType`. When the observation is
-         * performed, the entries should be cleared from the global Performance Timeline manually with `performance.clearMarks`.
          * @param name
+         * @return The PerformanceMark entry that was created
          */
-        mark(name: string, options?: MarkOptions): PerformanceMark;
+        mark(name?: string, options?: MarkOptions): PerformanceMark;
         /**
          * Creates a new PerformanceMeasure entry in the Performance Timeline.
          * A PerformanceMeasure is a subclass of PerformanceEntry whose performanceEntry.entryType is always 'measure',
@@ -289,74 +271,31 @@ declare module "perf_hooks" {
         measure(name: string, startMark?: string, endMark?: string): PerformanceMeasure;
         measure(name: string, options: MeasureOptions): PerformanceMeasure;
         /**
-         * _This property is an extension by Node.js. It is not available in Web browsers._
-         *
-         * An instance of the `PerformanceNodeTiming` class that provides performance metrics for specific Node.js operational milestones.
-         * @since v8.5.0
+         * An instance of the PerformanceNodeTiming class that provides performance metrics for specific Node.js operational milestones.
          */
         readonly nodeTiming: PerformanceNodeTiming;
         /**
-         * Returns the current high resolution millisecond timestamp, where 0 represents the start of the current `node` process.
-         * @since v8.5.0
+         * @return the current high resolution millisecond timestamp
          */
         now(): number;
         /**
-         * Sets the global performance resource timing buffer size to the specified number of "resource" type performance entry objects.
-         *
-         * By default the max buffer size is set to 250.
-         * @since v18.8.0
-         */
-        setResourceTimingBufferSize(maxSize: number): void;
-        /**
-         * The [`timeOrigin`](https://w3c.github.io/hr-time/#dom-performance-timeorigin) specifies the high resolution millisecond timestamp
-         * at which the current `node` process began, measured in Unix time.
-         * @since v8.5.0
+         * The timeOrigin specifies the high resolution millisecond timestamp from which all performance metric durations are measured.
          */
         readonly timeOrigin: number;
         /**
-         * _This property is an extension by Node.js. It is not available in Web browsers._
-         *
          * Wraps a function within a new function that measures the running time of the wrapped function.
-         * A `PerformanceObserver` must be subscribed to the `'function'` event type in order for the timing details to be accessed.
-         *
-         * ```js
-         * const {
-         *   performance,
-         *   PerformanceObserver,
-         * } = require('node:perf_hooks');
-         *
-         * function someFunction() {
-         *   console.log('hello world');
-         * }
-         *
-         * const wrapped = performance.timerify(someFunction);
-         *
-         * const obs = new PerformanceObserver((list) => {
-         *   console.log(list.getEntries()[0].duration);
-         *
-         *   performance.clearMarks();
-         *   performance.clearMeasures();
-         *   obs.disconnect();
-         * });
-         * obs.observe({ entryTypes: ['function'] });
-         *
-         * // A performance timeline entry will be created
-         * wrapped();
-         * ```
-         *
-         * If the wrapped function returns a promise, a finally handler will be attached to the promise and the duration will be reported
-         * once the finally handler is invoked.
+         * A PerformanceObserver must be subscribed to the 'function' event type in order for the timing details to be accessed.
          * @param fn
          */
         timerify<T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions): T;
         /**
-         * An object which is JSON representation of the performance object. It is similar to
-         * [`window.performance.toJSON`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/toJSON) in browsers.
-         * @since v16.1.0
+         * eventLoopUtilization is similar to CPU utilization except that it is calculated using high precision wall-clock time.
+         * It represents the percentage of time the event loop has spent outside the event loop's event provider (e.g. epoll_wait).
+         * No other CPU idle time is taken into consideration.
          */
-        toJSON(): any;
+        eventLoopUtilization: EventLoopUtilityFunction;
     }
-    class PerformanceObserverEntryList {
+    interface PerformanceObserverEntryList {
         /**
          * Returns a list of `PerformanceEntry` objects in chronological order
          * with respect to `performanceEntry.startTime`.
@@ -536,103 +475,6 @@ declare module "perf_hooks" {
                 },
         ): void;
     }
-    /**
-     * Provides detailed network timing data regarding the loading of an application's resources.
-     *
-     * The constructor of this class is not exposed to users directly.
-     * @since v18.2.0, v16.17.0
-     */
-    class PerformanceResourceTiming extends PerformanceEntry {
-        protected constructor();
-        /**
-         * The high resolution millisecond timestamp at immediately before dispatching the `fetch`
-         * request. If the resource is not intercepted by a worker the property will always return 0.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly workerStart: number;
-        /**
-         * The high resolution millisecond timestamp that represents the start time of the fetch which
-         * initiates the redirect.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly redirectStart: number;
-        /**
-         * The high resolution millisecond timestamp that will be created immediately after receiving
-         * the last byte of the response of the last redirect.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly redirectEnd: number;
-        /**
-         * The high resolution millisecond timestamp immediately before the Node.js starts to fetch the resource.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly fetchStart: number;
-        /**
-         * The high resolution millisecond timestamp immediately before the Node.js starts the domain name lookup
-         * for the resource.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly domainLookupStart: number;
-        /**
-         * The high resolution millisecond timestamp representing the time immediately after the Node.js finished
-         * the domain name lookup for the resource.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly domainLookupEnd: number;
-        /**
-         * The high resolution millisecond timestamp representing the time immediately before Node.js starts to
-         * establish the connection to the server to retrieve the resource.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly connectStart: number;
-        /**
-         * The high resolution millisecond timestamp representing the time immediately after Node.js finishes
-         * establishing the connection to the server to retrieve the resource.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly connectEnd: number;
-        /**
-         * The high resolution millisecond timestamp representing the time immediately before Node.js starts the
-         * handshake process to secure the current connection.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly secureConnectionStart: number;
-        /**
-         * The high resolution millisecond timestamp representing the time immediately before Node.js receives the
-         * first byte of the response from the server.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly requestStart: number;
-        /**
-         * The high resolution millisecond timestamp representing the time immediately after Node.js receives the
-         * last byte of the resource or immediately before the transport connection is closed, whichever comes first.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly responseEnd: number;
-        /**
-         * A number representing the size (in octets) of the fetched resource. The size includes the response header
-         * fields plus the response payload body.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly transferSize: number;
-        /**
-         * A number representing the size (in octets) received from the fetch (HTTP or cache), of the payload body, before
-         * removing any applied content-codings.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly encodedBodySize: number;
-        /**
-         * A number representing the size (in octets) received from the fetch (HTTP or cache), of the message body, after
-         * removing any applied content-codings.
-         * @since v18.2.0, v16.17.0
-         */
-        readonly decodedBodySize: number;
-        /**
-         * Returns a `object` that is the JSON representation of the `PerformanceResourceTiming` object
-         * @since v18.2.0, v16.17.0
-         */
-        toJSON(): any;
-    }
     namespace constants {
         const NODE_PERFORMANCE_GC_MAJOR: number;
         const NODE_PERFORMANCE_GC_MINOR: number;
@@ -657,15 +499,10 @@ declare module "perf_hooks" {
     }
     interface Histogram {
         /**
-         * The number of samples recorded by the histogram.
-         * @since v17.4.0, v16.14.0
-         */
-        readonly count: number;
-        /**
-         * The number of samples recorded by the histogram.
-         * v17.4.0, v16.14.0
+         * Returns a `Map` object detailing the accumulated percentile distribution.
+         * @since v11.10.0
          */
-        readonly countBigInt: bigint;
+        readonly percentiles: Map<number, number>;
         /**
          * The number of times the event loop delay exceeded the maximum 1 hour event
          * loop delay threshold.
@@ -673,67 +510,36 @@ declare module "perf_hooks" {
          */
         readonly exceeds: number;
         /**
-         * The number of times the event loop delay exceeded the maximum 1 hour event loop delay threshold.
-         * @since v17.4.0, v16.14.0
+         * The minimum recorded event loop delay.
+         * @since v11.10.0
          */
-        readonly exceedsBigInt: bigint;
+        readonly min: number;
         /**
          * The maximum recorded event loop delay.
          * @since v11.10.0
          */
         readonly max: number;
-        /**
-         * The maximum recorded event loop delay.
-         * v17.4.0, v16.14.0
-         */
-        readonly maxBigInt: number;
         /**
          * The mean of the recorded event loop delays.
          * @since v11.10.0
          */
         readonly mean: number;
         /**
-         * The minimum recorded event loop delay.
-         * @since v11.10.0
-         */
-        readonly min: number;
-        /**
-         * The minimum recorded event loop delay.
-         * v17.4.0, v16.14.0
-         */
-        readonly minBigInt: bigint;
-        /**
-         * Returns the value at the given percentile.
-         * @since v11.10.0
-         * @param percentile A percentile value in the range (0, 100].
-         */
-        percentile(percentile: number): number;
-        /**
-         * Returns the value at the given percentile.
-         * @since v17.4.0, v16.14.0
-         * @param percentile A percentile value in the range (0, 100].
-         */
-        percentileBigInt(percentile: number): bigint;
-        /**
-         * Returns a `Map` object detailing the accumulated percentile distribution.
+         * The standard deviation of the recorded event loop delays.
          * @since v11.10.0
          */
-        readonly percentiles: Map<number, number>;
-        /**
-         * Returns a `Map` object detailing the accumulated percentile distribution.
-         * @since v17.4.0, v16.14.0
-         */
-        readonly percentilesBigInt: Map<bigint, bigint>;
+        readonly stddev: number;
         /**
          * Resets the collected histogram data.
          * @since v11.10.0
          */
         reset(): void;
         /**
-         * The standard deviation of the recorded event loop delays.
+         * Returns the value at the given percentile.
          * @since v11.10.0
+         * @param percentile A percentile value in the range (0, 100].
          */
-        readonly stddev: number;
+        percentile(percentile: number): number;
     }
     interface IntervalHistogram extends Histogram {
         /**
@@ -758,6 +564,8 @@ declare module "perf_hooks" {
         /**
          * Calculates the amount of time (in nanoseconds) that has passed since the
          * previous call to `recordDelta()` and records that amount in the histogram.
+         *
+         * ## Examples
          * @since v15.9.0, v14.18.0
          */
         recordDelta(): void;
@@ -818,79 +626,11 @@ declare module "perf_hooks" {
      * @since v15.9.0, v14.18.0
      */
     function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
-    import {
-        performance as _performance,
-        PerformanceEntry as _PerformanceEntry,
-        PerformanceMark as _PerformanceMark,
-        PerformanceMeasure as _PerformanceMeasure,
-        PerformanceObserver as _PerformanceObserver,
-        PerformanceObserverEntryList as _PerformanceObserverEntryList,
-        PerformanceResourceTiming as _PerformanceResourceTiming,
-    } from "perf_hooks";
+    import { performance as _performance } from "perf_hooks";
     global {
         /**
-         * `PerformanceEntry` is a global reference for `require('node:perf_hooks').PerformanceEntry`
-         * @see https://nodejs.org/docs/latest-v20.x/api/globals.html#performanceentry
-         * @since v19.0.0
-         */
-        var PerformanceEntry: typeof globalThis extends {
-            onmessage: any;
-            PerformanceEntry: infer T;
-        } ? T
-            : typeof _PerformanceEntry;
-        /**
-         * `PerformanceMark` is a global reference for `require('node:perf_hooks').PerformanceMark`
-         * @see https://nodejs.org/docs/latest-v20.x/api/globals.html#performancemark
-         * @since v19.0.0
-         */
-        var PerformanceMark: typeof globalThis extends {
-            onmessage: any;
-            PerformanceMark: infer T;
-        } ? T
-            : typeof _PerformanceMark;
-        /**
-         * `PerformanceMeasure` is a global reference for `require('node:perf_hooks').PerformanceMeasure`
-         * @see https://nodejs.org/docs/latest-v20.x/api/globals.html#performancemeasure
-         * @since v19.0.0
-         */
-        var PerformanceMeasure: typeof globalThis extends {
-            onmessage: any;
-            PerformanceMeasure: infer T;
-        } ? T
-            : typeof _PerformanceMeasure;
-        /**
-         * `PerformanceObserver` is a global reference for `require('node:perf_hooks').PerformanceObserver`
-         * @see https://nodejs.org/docs/latest-v20.x/api/globals.html#performanceobserver
-         * @since v19.0.0
-         */
-        var PerformanceObserver: typeof globalThis extends {
-            onmessage: any;
-            PerformanceObserver: infer T;
-        } ? T
-            : typeof _PerformanceObserver;
-        /**
-         * `PerformanceObserverEntryList` is a global reference for `require('node:perf_hooks').PerformanceObserverEntryList`
-         * @see https://nodejs.org/docs/latest-v20.x/api/globals.html#performanceobserverentrylist
-         * @since v19.0.0
-         */
-        var PerformanceObserverEntryList: typeof globalThis extends {
-            onmessage: any;
-            PerformanceObserverEntryList: infer T;
-        } ? T
-            : typeof _PerformanceObserverEntryList;
-        /**
-         * `PerformanceResourceTiming` is a global reference for `require('node:perf_hooks').PerformanceResourceTiming`
-         * @see https://nodejs.org/docs/latest-v20.x/api/globals.html#performanceresourcetiming
-         * @since v19.0.0
-         */
-        var PerformanceResourceTiming: typeof globalThis extends {
-            onmessage: any;
-            PerformanceResourceTiming: infer T;
-        } ? T
-            : typeof _PerformanceResourceTiming;
-        /**
-         * `performance` is a global reference for `require('node:perf_hooks').performance`
-         * @see https://nodejs.org/docs/latest-v20.x/api/globals.html#performance
+         * `performance` is a global reference for `require('perf_hooks').performance`
+         * https://nodejs.org/api/globals.html#performance
          * @since v16.0.0
          */
         var performance: typeof globalThis extends {

node/process.d.ts

@@ -433,13 +433,13 @@ declare module "process" {
                  * the same execution environment as the parent.
                  *
                  * ```bash
-                 * node --icu-data-dir=./foo --require ./bar.js script.js --version
+                 * node --harmony script.js --version
                  * ```
                  *
                  * Results in `process.execArgv`:
                  *
                  * ```js
-                 * ["--icu-data-dir=./foo", "--require", "./bar.js"]
+                 * ['--harmony']
                  * ```
                  *
                  * And `process.argv`:
@@ -1293,21 +1293,14 @@ declare module "process" {
                 /**
                  * Gets the amount of memory available to the process (in bytes) based on
                  * limits imposed by the OS. If there is no such constraint, or the constraint
-                 * is unknown, `0` is returned.
+                 * is unknown, `undefined` is returned.
                  *
                  * See [`uv_get_constrained_memory`](https://docs.libuv.org/en/v1.x/misc.html#c.uv_get_constrained_memory) for more
                  * information.
                  * @since v19.6.0, v18.15.0
                  * @experimental
                  */
-                constrainedMemory(): number;
-                /**
-                 * Gets the amount of free memory that is still available to the process (in bytes).
-                 * See [`uv_get_available_memory`](https://nodejs.org/docs/latest-v20.x/api/process.html#processavailablememory) for more information.
-                 * @experimental
-                 * @since v20.13.0
-                 */
-                availableMemory(): number;
+                constrainedMemory(): number | undefined;
                 /**
                  * The `process.cpuUsage()` method returns the user and system CPU time usage of
                  * the current process, in an object with properties `user` and `system`, whose

node/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.13.1/lib/punycode.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/punycode.js)
  */
 declare module "punycode" {
     /**

node/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.13.1/lib/querystring.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/querystring.js)
  */
 declare module "querystring" {
     interface StringifyOptions {

node/readline.d.ts

@@ -31,7 +31,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.13.1/lib/readline.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/readline.js)
  */
 declare module "readline" {
     import { Abortable, EventEmitter } from "node:events";

node/repl.d.ts

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

node/stream.d.ts

@@ -15,7 +15,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.13.1/lib/stream.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/stream.js)
  */
 declare module "stream" {
     import { Abortable, EventEmitter } from "node:events";
@@ -272,14 +272,14 @@ declare module "stream" {
          *   });
          * ```
          *
-         * The `readable.resume()` method has no effect if there is a `'readable'` event listener.
+         * The `readable.resume()` method has no effect if there is a `'readable'`event listener.
          * @since v0.9.4
          */
         resume(): this;
         /**
-         * The `readable.isPaused()` method returns the current operating state of the `Readable`.
-         * This is used primarily by the mechanism that underlies the `readable.pipe()` method.
-         * In most typical cases, there will be no reason to use this method directly.
+         * The `readable.isPaused()` method returns the current operating state of the `Readable`. This is
+         * used primarily by the mechanism that underlies the `readable.pipe()` method. In most typical cases,
+         * there will be no reason to use this method directly.
          *
          * ```js
          * const readable = new stream.Readable();
@@ -381,8 +381,8 @@ declare module "stream" {
          * however it is best to simply avoid calling `readable.unshift()` while in the
          * process of performing a read.
          * @since v0.9.11
-         * @param chunk Chunk of data to unshift onto the read queue. For streams not operating in object mode, `chunk` must
-         * be a {string}, {Buffer}, {TypedArray}, {DataView} or `null`. For object mode streams, `chunk` may be any JavaScript value.
+         * @param chunk Chunk of data to unshift onto the read queue. For streams not operating in object mode, `chunk` must be a string, `Buffer`, `Uint8Array`, or `null`. For object mode
+         * streams, `chunk` may be any JavaScript value.
          * @param encoding Encoding of string chunks. Must be a valid `Buffer` encoding, such as `'utf8'` or `'ascii'`.
          */
         unshift(chunk: any, encoding?: BufferEncoding): void;
@@ -782,8 +782,8 @@ declare module "stream" {
          *
          * A `Writable` stream in object mode will always ignore the `encoding` argument.
          * @since v0.9.4
-         * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer},
-         * {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`.
+         * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a string, `Buffer` or `Uint8Array`. For object mode streams, `chunk` may be any
+         * JavaScript value other than `null`.
          * @param [encoding='utf8'] The encoding, if `chunk` is a string.
          * @param callback Callback for when this chunk of data is flushed.
          * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
@@ -813,8 +813,8 @@ declare module "stream" {
          * // Writing more now is not allowed!
          * ```
          * @since v0.9.4
-         * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer},
-         * {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`.
+         * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a string, `Buffer` or `Uint8Array`. For object mode streams, `chunk` may be any
+         * JavaScript value other than `null`.
          * @param encoding The encoding if `chunk` is a string
          * @param callback Callback for when the stream is finished.
          */
@@ -1300,8 +1300,8 @@ declare module "stream" {
          * Attaches an AbortSignal to a readable or writeable stream. This lets code
          * control stream destruction using an `AbortController`.
          *
-         * Calling `abort` on the `AbortController` corresponding to the passed `AbortSignal` will behave the same way as calling `.destroy(new AbortError())` on the
-         * stream, and `controller.error(new AbortError())` for webstreams.
+         * Calling `abort` on the `AbortController` corresponding to the passed `AbortSignal` will behave the same way as
+         * calling `.destroy(new AbortError())` on the stream, and `controller.error(new AbortError())` for webstreams.
          *
          * ```js
          * const fs = require('node:fs');
@@ -1417,7 +1417,7 @@ declare module "stream" {
          * Especially useful in error handling scenarios where a stream is destroyed
          * prematurely (like an aborted HTTP request), and will not emit `'end'` or `'finish'`.
          *
-         * The `finished` API provides [`promise version`](https://nodejs.org/docs/latest-v20.x/api/stream.html#streamfinishedstream-options).
+         * The `finished` API provides [promise version](https://nodejs.org/docs/latest-v20.x/api/stream.html#streamfinishedstream-options).
          *
          * `stream.finished()` leaves dangling event listeners (in particular `'error'`, `'end'`, `'finish'` and `'close'`) after `callback` has been
          * invoked. The reason for this is so that unexpected `'error'` events (due to
@@ -1505,7 +1505,7 @@ declare module "stream" {
          * );
          * ```
          *
-         * The `pipeline` API provides a [`promise version`](https://nodejs.org/docs/latest-v20.x/api/stream.html#streampipelinesource-transforms-destination-options).
+         * The `pipeline` API provides a [promise version](https://nodejs.org/docs/latest-v20.x/api/stream.html#streampipelinesource-transforms-destination-options).
          *
          * `stream.pipeline()` will call `stream.destroy(err)` on all streams except:
          *