@types/node 18.19.76 → 18.19.78

node v18.19/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/v18.
 
 ### Additional Details
- * Last updated: Thu, 13 Feb 2025 22:34:15 GMT
+ * Last updated: Fri, 28 Feb 2025 22:02:14 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

node v18.19/buffer.buffer.d.ts

@@ -1,4 +1,6 @@
 declare module "buffer" {
+    type ImplicitArrayBuffer<T extends WithImplicitCoercion<ArrayBufferLike>> = T extends
+        { valueOf(): infer V extends ArrayBufferLike } ? V : T;
     global {
         interface BufferConstructor {
             // see buffer.d.ts for implementation shared with all TypeScript versions
@@ -24,7 +26,7 @@ declare module "buffer" {
              * @param array The octets to store.
              * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
              */
-            new(array: Uint8Array): Buffer<ArrayBuffer>;
+            new(array: ArrayLike<number>): Buffer<ArrayBuffer>;
             /**
              * Produces a Buffer backed by the same allocated memory as
              * the given {ArrayBuffer}/{SharedArrayBuffer}.
@@ -33,20 +35,6 @@ declare module "buffer" {
              * @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead.
              */
             new<TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(arrayBuffer: TArrayBuffer): Buffer<TArrayBuffer>;
-            /**
-             * Allocates a new buffer containing the given {array} of octets.
-             *
-             * @param array The octets to store.
-             * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
-             */
-            new(array: readonly any[]): Buffer<ArrayBuffer>;
-            /**
-             * Copies the passed {buffer} data onto a new {Buffer} instance.
-             *
-             * @param buffer The buffer to copy.
-             * @deprecated since v10.0.0 - Use `Buffer.from(buffer)` instead.
-             */
-            new(buffer: Buffer): Buffer<ArrayBuffer>;
             /**
              * Allocates a new `Buffer` using an `array` of bytes in the range `0` – `255`.
              * Array entries outside that range will be truncated to fit into it.
@@ -57,41 +45,116 @@ declare module "buffer" {
              * // Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.
              * const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
              * ```
-             *
-             * If `array` is an `Array`\-like object (that is, one with a `length` property of
+             * 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<TArrayBuffer extends ArrayBufferLike>(
-                arrayBuffer: WithImplicitCoercion<TArrayBuffer>,
-                byteOffset?: number,
-                length?: number,
-            ): Buffer<TArrayBuffer>;
+            from(array: WithImplicitCoercion<ArrayLike<number>>): Buffer<ArrayBuffer>;
             /**
-             * Creates a new Buffer using the passed {data}
-             * @param data data to create a new Buffer
+             * This creates a view of the `ArrayBuffer` without copying the underlying
+             * memory. For example, when passed a reference to the `.buffer` property of a
+             * `TypedArray` instance, the newly created `Buffer` will share the same
+             * allocated memory as the `TypedArray`'s underlying `ArrayBuffer`.
+             *
+             * ```js
+             * import { Buffer } from 'node:buffer';
+             *
+             * const arr = new Uint16Array(2);
+             *
+             * arr[0] = 5000;
+             * arr[1] = 4000;
+             *
+             * // Shares memory with `arr`.
+             * const buf = Buffer.from(arr.buffer);
+             *
+             * console.log(buf);
+             * // Prints: <Buffer 88 13 a0 0f>
+             *
+             * // Changing the original Uint16Array changes the Buffer also.
+             * arr[1] = 6000;
+             *
+             * console.log(buf);
+             * // Prints: <Buffer 88 13 70 17>
+             * ```
+             * The optional `byteOffset` and `length` arguments specify a memory range within
+             * the `arrayBuffer` that will be shared by the `Buffer`.
+             *
+             * ```js
+             * import { Buffer } from 'node:buffer';
+             *
+             * const ab = new ArrayBuffer(10);
+             * const buf = Buffer.from(ab, 0, 2);
+             *
+             * console.log(buf.length);
+             * // Prints: 2
+             * ```
+             *
+             * A `TypeError` will be thrown if `arrayBuffer` is not an `ArrayBuffer` or a
+             * `SharedArrayBuffer` or another type appropriate for `Buffer.from()`
+             * variants.
+             *
+             * It is important to remember that a backing `ArrayBuffer` can cover a range
+             * of memory that extends beyond the bounds of a `TypedArray` view. A new
+             * `Buffer` created using the `buffer` property of a `TypedArray` may extend
+             * beyond the range of the `TypedArray`:
+             *
+             * ```js
+             * import { Buffer } from 'node:buffer';
+             *
+             * const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]); // 4 elements
+             * const arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements
+             * console.log(arrA.buffer === arrB.buffer); // true
+             *
+             * const buf = Buffer.from(arrB.buffer);
+             * console.log(buf);
+             * // Prints: <Buffer 63 64 65 66>
+             * ```
+             * @since v5.10.0
+             * @param arrayBuffer An `ArrayBuffer`, `SharedArrayBuffer`, for example the
+             * `.buffer` property of a `TypedArray`.
+             * @param byteOffset Index of first byte to expose. **Default:** `0`.
+             * @param length Number of bytes to expose. **Default:**
+             * `arrayBuffer.byteLength - byteOffset`.
              */
-            from(data: Uint8Array | readonly number[]): Buffer<ArrayBuffer>;
-            from(data: WithImplicitCoercion<Uint8Array | readonly number[] | string>): Buffer<ArrayBuffer>;
+            from<TArrayBuffer extends WithImplicitCoercion<ArrayBufferLike>>(
+                arrayBuffer: TArrayBuffer,
+                byteOffset?: number,
+                length?: number,
+            ): Buffer<ImplicitArrayBuffer<TArrayBuffer>>;
             /**
-             * Creates a new Buffer containing the given JavaScript string {str}.
-             * If provided, the {encoding} parameter identifies the character encoding.
-             * If not provided, {encoding} defaults to 'utf8'.
+             * Creates a new `Buffer` containing `string`. The `encoding` parameter identifies
+             * the character encoding to be used when converting `string` into bytes.
+             *
+             * ```js
+             * import { Buffer } from 'node:buffer';
+             *
+             * const buf1 = Buffer.from('this is a tést');
+             * const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');
+             *
+             * console.log(buf1.toString());
+             * // Prints: this is a tést
+             * console.log(buf2.toString());
+             * // Prints: this is a tést
+             * console.log(buf1.toString('latin1'));
+             * // Prints: this is a tést
+             * ```
+             *
+             * A `TypeError` will be thrown if `string` is not a string or another type
+             * appropriate for `Buffer.from()` variants.
+             * @since v5.10.0
+             * @param string A string to encode.
+             * @param encoding The encoding of `string`. **Default:** `'utf8'`.
              */
-            from(
-                str:
-                    | WithImplicitCoercion<string>
-                    | {
-                        [Symbol.toPrimitive](hint: "string"): string;
-                    },
-                encoding?: BufferEncoding,
-            ): Buffer<ArrayBuffer>;
+            from(string: WithImplicitCoercion<string>, encoding?: BufferEncoding): Buffer<ArrayBuffer>;
             /**
              * Creates a new Buffer using the passed {data}
              * @param values to create a new Buffer
@@ -382,4 +445,10 @@ declare module "buffer" {
             subarray(start?: number, end?: number): Buffer<TArrayBuffer>;
         }
     }
+    /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
+    var SlowBuffer: {
+        /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
+        new(size: number): Buffer<ArrayBuffer>;
+        prototype: Buffer;
+    };
 }

node v18.19/buffer.d.ts

@@ -104,11 +104,6 @@ declare module "buffer" {
      * @param toEnc To target encoding.
      */
     export function transcode(source: Uint8Array, fromEnc: TranscodeEncoding, toEnc: TranscodeEncoding): Buffer;
-    export const SlowBuffer: {
-        /** @deprecated since v6.0.0, use `Buffer.allocUnsafeSlow()` */
-        new(size: number): Buffer;
-        prototype: Buffer;
-    };
     /**
      * Resolves a `'blob:nodedata:...'` an associated `Blob` object registered using
      * a prior call to `URL.createObjectURL()`.
@@ -216,7 +211,10 @@ declare module "buffer" {
     }
     export import atob = globalThis.atob;
     export import btoa = globalThis.btoa;
-
+    export type WithImplicitCoercion<T> =
+        | T
+        | { valueOf(): T }
+        | (T extends string ? { [Symbol.toPrimitive](hint: "string"): T } : never);
     global {
         namespace NodeJS {
             export { BufferEncoding };
@@ -234,11 +232,6 @@ declare module "buffer" {
             | "latin1"
             | "binary"
             | "hex";
-        type WithImplicitCoercion<T> =
-            | T
-            | {
-                valueOf(): T;
-            };
         /**
          * Raw data is stored in instances of the Buffer class.
          * A Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap.  A Buffer cannot be resized.

node v18.19/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "18.19.76",
+    "version": "18.19.78",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -220,6 +220,6 @@
         "undici-types": "~5.26.4"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "8b84ac7ae7decd715ecc009f000a5d2ef12d25a5771e69a2c02890b57118880d",
+    "typesPublisherContentHash": "53c96e56ee2759566e81a31cb23f4874fe03fa92030604a19231d864af73dbcf",
     "typeScriptVersion": "5.0"
 }

node v18.19/stream.d.ts

@@ -20,12 +20,11 @@ declare module "stream" {
     import { Abortable, EventEmitter } from "node:events";
     import { Blob as NodeBlob } from "node:buffer";
     import * as streamPromises from "node:stream/promises";
-    import * as streamConsumers from "node:stream/consumers";
     import * as streamWeb from "node:stream/web";
 
     type ComposeFnParam = (source: any) => void;
 
-    class internal extends EventEmitter {
+    class Stream extends EventEmitter {
         pipe<T extends NodeJS.WritableStream>(
             destination: T,
             options?: {
@@ -37,10 +36,10 @@ declare module "stream" {
             options?: { signal: AbortSignal },
         ): T;
     }
-    namespace internal {
-        class Stream extends internal {
-            constructor(opts?: ReadableOptions);
-        }
+    namespace Stream {
+        export { Stream, streamPromises as promises };
+    }
+    namespace Stream {
         interface StreamOptions<T extends Stream> extends Abortable {
             emitClose?: boolean | undefined;
             highWaterMark?: number | undefined;
@@ -49,9 +48,9 @@ declare module "stream" {
             destroy?(this: T, error: Error | null, callback: (error?: Error | null) => void): void;
             autoDestroy?: boolean | undefined;
         }
-        interface ReadableOptions extends StreamOptions<Readable> {
+        interface ReadableOptions<T extends Readable = Readable> extends StreamOptions<T> {
             encoding?: BufferEncoding | undefined;
-            read?(this: Readable, size: number): void;
+            read?(this: T, size: number): void;
         }
         interface ArrayOptions {
             /** the maximum concurrent invocations of `fn` to call on the stream at once. **Default: 1**. */
@@ -686,24 +685,24 @@ declare module "stream" {
              */
             [Symbol.asyncDispose](): Promise<void>;
         }
-        interface WritableOptions extends StreamOptions<Writable> {
+        interface WritableOptions<T extends Writable = Writable> extends StreamOptions<T> {
             decodeStrings?: boolean | undefined;
             defaultEncoding?: BufferEncoding | undefined;
             write?(
-                this: Writable,
+                this: T,
                 chunk: any,
                 encoding: BufferEncoding,
                 callback: (error?: Error | null) => void,
             ): void;
             writev?(
-                this: Writable,
+                this: T,
                 chunks: Array<{
                     chunk: any;
                     encoding: BufferEncoding;
                 }>,
                 callback: (error?: Error | null) => void,
             ): void;
-            final?(this: Writable, callback: (error?: Error | null) => void): void;
+            final?(this: T, callback: (error?: Error | null) => void): void;
         }
         /**
          * @since v0.9.4
@@ -1011,26 +1010,13 @@ declare module "stream" {
             removeListener(event: "unpipe", listener: (src: Readable) => void): this;
             removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
         }
-        interface DuplexOptions extends ReadableOptions, WritableOptions {
+        interface DuplexOptions<T extends Duplex = Duplex> extends ReadableOptions<T>, WritableOptions<T> {
             allowHalfOpen?: boolean | undefined;
             readableObjectMode?: boolean | undefined;
             writableObjectMode?: boolean | undefined;
             readableHighWaterMark?: number | undefined;
             writableHighWaterMark?: number | undefined;
             writableCorked?: number | undefined;
-            construct?(this: Duplex, callback: (error?: Error | null) => void): void;
-            read?(this: Duplex, size: number): void;
-            write?(this: Duplex, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-            writev?(
-                this: Duplex,
-                chunks: Array<{
-                    chunk: any;
-                    encoding: BufferEncoding;
-                }>,
-                callback: (error?: Error | null) => void,
-            ): void;
-            final?(this: Duplex, callback: (error?: Error | null) => void): void;
-            destroy?(this: Duplex, error: Error | null, callback: (error?: Error | null) => void): void;
         }
         /**
          * Duplex streams are streams that implement both the `Readable` and `Writable` interfaces.
@@ -1042,17 +1028,7 @@ declare module "stream" {
          * * `crypto streams`
          * @since v0.9.4
          */
-        class Duplex extends Readable implements Writable {
-            readonly writable: boolean;
-            readonly writableEnded: boolean;
-            readonly writableFinished: boolean;
-            readonly writableHighWaterMark: number;
-            readonly writableLength: number;
-            readonly writableObjectMode: boolean;
-            readonly writableCorked: number;
-            readonly writableNeedDrain: boolean;
-            readonly closed: boolean;
-            readonly errored: Error | null;
+        class Duplex extends Stream implements NodeJS.ReadWriteStream {
             /**
              * If `false` then the stream will automatically end the writable side when the
              * readable side ends. Set initially by the `allowHalfOpen` constructor option,
@@ -1097,24 +1073,6 @@ declare module "stream" {
                     | Promise<any>
                     | Object,
             ): Duplex;
-            _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-            _writev?(
-                chunks: Array<{
-                    chunk: any;
-                    encoding: BufferEncoding;
-                }>,
-                callback: (error?: Error | null) => void,
-            ): void;
-            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
-            _final(callback: (error?: Error | null) => void): void;
-            write(chunk: any, encoding?: BufferEncoding, cb?: (error: Error | null | undefined) => void): boolean;
-            write(chunk: any, cb?: (error: Error | null | undefined) => void): boolean;
-            setDefaultEncoding(encoding: BufferEncoding): this;
-            end(cb?: () => void): this;
-            end(chunk: any, cb?: () => void): this;
-            end(chunk: any, encoding?: BufferEncoding, cb?: () => void): this;
-            cork(): void;
-            uncork(): void;
             /**
              * Event emitter
              * The defined events on documents including:
@@ -1215,28 +1173,11 @@ declare module "stream" {
             removeListener(event: "unpipe", listener: (src: Readable) => void): this;
             removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
         }
+        interface Duplex extends Readable, Writable {}
         type TransformCallback = (error?: Error | null, data?: any) => void;
-        interface TransformOptions extends DuplexOptions {
-            construct?(this: Transform, callback: (error?: Error | null) => void): void;
-            read?(this: Transform, size: number): void;
-            write?(
-                this: Transform,
-                chunk: any,
-                encoding: BufferEncoding,
-                callback: (error?: Error | null) => void,
-            ): void;
-            writev?(
-                this: Transform,
-                chunks: Array<{
-                    chunk: any;
-                    encoding: BufferEncoding;
-                }>,
-                callback: (error?: Error | null) => void,
-            ): void;
-            final?(this: Transform, callback: (error?: Error | null) => void): void;
-            destroy?(this: Transform, error: Error | null, callback: (error?: Error | null) => void): void;
-            transform?(this: Transform, chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
-            flush?(this: Transform, callback: TransformCallback): void;
+        interface TransformOptions<T extends Transform = Transform> extends DuplexOptions<T> {
+            transform?(this: T, chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
+            flush?(this: T, callback: TransformCallback): void;
         }
         /**
          * Transform streams are `Duplex` streams where the output is in some way
@@ -1724,11 +1665,8 @@ declare module "stream" {
          * @since v17.4.0
          */
         function isReadable(stream: Readable | NodeJS.ReadableStream): boolean;
-
-        const promises: typeof streamPromises;
-        const consumers: typeof streamConsumers;
     }
-    export = internal;
+    export = Stream;
 }
 declare module "node:stream" {
     import stream = require("stream");

node v18.19/ts5.6/buffer.buffer.d.ts

@@ -24,7 +24,7 @@ declare module "buffer" {
              * @param array The octets to store.
              * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
              */
-            new(array: Uint8Array): Buffer;
+            new(array: ArrayLike<number>): Buffer;
             /**
              * Produces a Buffer backed by the same allocated memory as
              * the given {ArrayBuffer}/{SharedArrayBuffer}.
@@ -33,20 +33,6 @@ declare module "buffer" {
              * @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead.
              */
             new(arrayBuffer: ArrayBuffer | SharedArrayBuffer): Buffer;
-            /**
-             * Allocates a new buffer containing the given {array} of octets.
-             *
-             * @param array The octets to store.
-             * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
-             */
-            new(array: readonly any[]): Buffer;
-            /**
-             * Copies the passed {buffer} data onto a new {Buffer} instance.
-             *
-             * @param buffer The buffer to copy.
-             * @deprecated since v10.0.0 - Use `Buffer.from(buffer)` instead.
-             */
-            new(buffer: Buffer): Buffer;
             /**
              * Allocates a new `Buffer` using an `array` of bytes in the range `0` – `255`.
              * Array entries outside that range will be truncated to fit into it.
@@ -57,16 +43,85 @@ declare module "buffer" {
              * // Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.
              * const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
              * ```
-             *
-             * If `array` is an `Array`\-like object (that is, one with a `length` property of
+             * 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(array: WithImplicitCoercion<ArrayLike<number>>): Buffer;
+            /**
+             * This creates a view of the `ArrayBuffer` without copying the underlying
+             * memory. For example, when passed a reference to the `.buffer` property of a
+             * `TypedArray` instance, the newly created `Buffer` will share the same
+             * allocated memory as the `TypedArray`'s underlying `ArrayBuffer`.
+             *
+             * ```js
+             * import { Buffer } from 'node:buffer';
+             *
+             * const arr = new Uint16Array(2);
+             *
+             * arr[0] = 5000;
+             * arr[1] = 4000;
+             *
+             * // Shares memory with `arr`.
+             * const buf = Buffer.from(arr.buffer);
+             *
+             * console.log(buf);
+             * // Prints: <Buffer 88 13 a0 0f>
+             *
+             * // Changing the original Uint16Array changes the Buffer also.
+             * arr[1] = 6000;
+             *
+             * console.log(buf);
+             * // Prints: <Buffer 88 13 70 17>
+             * ```
+             * The optional `byteOffset` and `length` arguments specify a memory range within
+             * the `arrayBuffer` that will be shared by the `Buffer`.
+             *
+             * ```js
+             * import { Buffer } from 'node:buffer';
+             *
+             * const ab = new ArrayBuffer(10);
+             * const buf = Buffer.from(ab, 0, 2);
+             *
+             * console.log(buf.length);
+             * // Prints: 2
+             * ```
+             *
+             * A `TypeError` will be thrown if `arrayBuffer` is not an `ArrayBuffer` or a
+             * `SharedArrayBuffer` or another type appropriate for `Buffer.from()`
+             * variants.
+             *
+             * It is important to remember that a backing `ArrayBuffer` can cover a range
+             * of memory that extends beyond the bounds of a `TypedArray` view. A new
+             * `Buffer` created using the `buffer` property of a `TypedArray` may extend
+             * beyond the range of the `TypedArray`:
+             *
+             * ```js
+             * import { Buffer } from 'node:buffer';
+             *
+             * const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]); // 4 elements
+             * const arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements
+             * console.log(arrA.buffer === arrB.buffer); // true
+             *
+             * const buf = Buffer.from(arrB.buffer);
+             * console.log(buf);
+             * // Prints: <Buffer 63 64 65 66>
+             * ```
              * @since v5.10.0
+             * @param arrayBuffer An `ArrayBuffer`, `SharedArrayBuffer`, for example the
+             * `.buffer` property of a `TypedArray`.
+             * @param byteOffset Index of first byte to expose. **Default:** `0`.
+             * @param length Number of bytes to expose. **Default:**
+             * `arrayBuffer.byteLength - byteOffset`.
              */
             from(
                 arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>,
@@ -74,24 +129,30 @@ declare module "buffer" {
                 length?: number,
             ): Buffer;
             /**
-             * Creates a new Buffer using the passed {data}
-             * @param data data to create a new Buffer
-             */
-            from(data: Uint8Array | readonly number[]): Buffer;
-            from(data: WithImplicitCoercion<Uint8Array | readonly number[] | string>): Buffer;
-            /**
-             * Creates a new Buffer containing the given JavaScript string {str}.
-             * If provided, the {encoding} parameter identifies the character encoding.
-             * If not provided, {encoding} defaults to 'utf8'.
+             * Creates a new `Buffer` containing `string`. The `encoding` parameter identifies
+             * the character encoding to be used when converting `string` into bytes.
+             *
+             * ```js
+             * import { Buffer } from 'node:buffer';
+             *
+             * const buf1 = Buffer.from('this is a tést');
+             * const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');
+             *
+             * console.log(buf1.toString());
+             * // Prints: this is a tést
+             * console.log(buf2.toString());
+             * // Prints: this is a tést
+             * console.log(buf1.toString('latin1'));
+             * // Prints: this is a tést
+             * ```
+             *
+             * A `TypeError` will be thrown if `string` is not a string or another type
+             * appropriate for `Buffer.from()` variants.
+             * @since v5.10.0
+             * @param string A string to encode.
+             * @param encoding The encoding of `string`. **Default:** `'utf8'`.
              */
-            from(
-                str:
-                    | WithImplicitCoercion<string>
-                    | {
-                        [Symbol.toPrimitive](hint: "string"): string;
-                    },
-                encoding?: BufferEncoding,
-            ): Buffer;
+            from(string: WithImplicitCoercion<string>, encoding?: BufferEncoding): Buffer;
             /**
              * Creates a new Buffer using the passed {data}
              * @param values to create a new Buffer
@@ -382,4 +443,10 @@ declare module "buffer" {
             subarray(start?: number, end?: number): Buffer;
         }
     }
+    /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
+    var SlowBuffer: {
+        /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
+        new(size: number): Buffer;
+        prototype: Buffer;
+    };
 }