@types/node 16.18.78 → 16.18.80

node v16.18/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/v16.
 
 ### Additional Details
- * Last updated: Wed, 31 Jan 2024 19:35:04 GMT
+ * Last updated: Thu, 08 Feb 2024 20:35:44 GMT
  * Dependencies: none
 
 # Credits

node v16.18/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "16.18.78",
+    "version": "16.18.80",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -222,6 +222,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "22a2fa011bf9e331acc51df56038056b552f8b9da6edd88d5c123bc5952476ff",
+    "typesPublisherContentHash": "0747ef1ff42367a2c659aab5fc827387e23d727f290cd39647ba32a7618902a6",
     "typeScriptVersion": "4.6"
 }

node v16.18/ts4.8/crypto.d.ts

@@ -1205,11 +1205,13 @@ declare module "crypto" {
         format?: KeyFormat | undefined;
         type?: "pkcs1" | "pkcs8" | "sec1" | undefined;
         passphrase?: string | Buffer | undefined;
+        encoding?: string | undefined;
     }
     interface PublicKeyInput {
         key: string | Buffer;
         format?: KeyFormat | undefined;
         type?: "pkcs1" | "spki" | undefined;
+        encoding?: string | undefined;
     }
     /**
      * Asynchronously generates a new random secret key of the given `length`. The`type` will determine which validations will be performed on the `length`.
@@ -3490,12 +3492,13 @@ declare module "crypto" {
          */
         disableEntropyCache?: boolean | undefined;
     }
+    type UUID = `${string}-${string}-${string}-${string}-${string}`;
     /**
      * Generates a random [RFC 4122](https://www.rfc-editor.org/rfc/rfc4122.txt) version 4 UUID. The UUID is generated using a
      * cryptographic pseudorandom number generator.
      * @since v15.6.0
      */
-    function randomUUID(options?: RandomUUIDOptions): string;
+    function randomUUID(options?: RandomUUIDOptions): UUID;
     interface X509CheckOptions {
         /**
          * @default 'always'
@@ -3978,7 +3981,7 @@ declare module "crypto" {
              * The UUID is generated using a cryptographic pseudorandom number generator.
              * @since v16.7.0
              */
-            randomUUID(): string;
+            randomUUID(): UUID;
             CryptoKey: CryptoKeyConstructor;
         }
         // This constructor throws ILLEGAL_CONSTRUCTOR so it should not be newable.

node v16.18/ts4.8/diagnostics_channel.d.ts

@@ -57,6 +57,7 @@ declare module "diagnostics_channel" {
      * @return The named channel object
      */
     function channel(name: string | symbol): Channel;
+    type ChannelListener = (message: unknown, name: string | symbol) => void;
     /**
      * Register a message handler to subscribe to this channel. This message handler will be run synchronously
      * whenever a message is published to the channel. Any errors thrown in the message handler will
@@ -96,7 +97,6 @@ declare module "diagnostics_channel" {
      * @returns `true` if the handler was found, `false` otherwise
      */
     function unsubscribe(name: string | symbol, onMessage: ChannelListener): boolean;
-    type ChannelListener = (message: unknown, name: string | symbol) => void;
     /**
      * The class `Channel` represents an individual named channel within the data
      * pipeline. It is use to track subscribers and to publish messages when there

node v16.18/ts4.8/dns/promises.d.ts

@@ -353,6 +353,7 @@ declare module "dns/promises" {
         resolve4: typeof resolve4;
         resolve6: typeof resolve6;
         resolveAny: typeof resolveAny;
+        resolveCaa: typeof resolveCaa;
         resolveCname: typeof resolveCname;
         resolveMx: typeof resolveMx;
         resolveNaptr: typeof resolveNaptr;

node v16.18/ts4.8/dns.d.ts

@@ -761,6 +761,7 @@ declare module "dns" {
         resolve4: typeof resolve4;
         resolve6: typeof resolve6;
         resolveAny: typeof resolveAny;
+        resolveCaa: typeof resolveCaa;
         resolveCname: typeof resolveCname;
         resolveMx: typeof resolveMx;
         resolveNaptr: typeof resolveNaptr;

node v16.18/ts4.8/events.d.ts

@@ -35,6 +35,8 @@
  * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/events.js)
  */
 declare module "events" {
+    import { AsyncResource, AsyncResourceOptions } from "node:async_hooks";
+
     interface EventEmitterOptions {
         /**
          * Enables automatic capturing of promise rejection.
@@ -72,6 +74,9 @@ declare module "events" {
      */
     class EventEmitter {
         constructor(options?: EventEmitterOptions);
+
+        [EventEmitter.captureRejectionSymbol]?(error: Error, event: string, ...args: any[]): void;
+
         /**
          * Creates a `Promise` that is fulfilled when the `EventEmitter` emits the given
          * event or that is rejected if the `EventEmitter` emits `'error'` while waiting.
@@ -314,10 +319,54 @@ declare module "events" {
              */
             signal?: AbortSignal | undefined;
         }
+
+        export interface EventEmitterReferencingAsyncResource extends AsyncResource {
+            readonly eventEmitter: EventEmitterAsyncResource;
+        }
+
+        export interface EventEmitterAsyncResourceOptions extends AsyncResourceOptions, EventEmitterOptions {
+            /**
+             * The type of async event, this is required when instantiating `EventEmitterAsyncResource`
+             * directly rather than as a child class.
+             * @default new.target.name if instantiated as a child class.
+             */
+            name?: string;
+        }
+
+        /**
+         * Integrates `EventEmitter` with `AsyncResource` for `EventEmitter`s that require
+         * manual async tracking. Specifically, all events emitted by instances of
+         * `EventEmitterAsyncResource` will run within its async context.
+         *
+         * The EventEmitterAsyncResource class has the same methods and takes the
+         * same options as EventEmitter and AsyncResource themselves.
+         * @throws if `options.name` is not provided when instantiated directly.
+         * @since v17.4.0, v16.14.0
+         */
+        export class EventEmitterAsyncResource extends EventEmitter {
+            /**
+             * @param options Only optional in child class.
+             */
+            constructor(options?: EventEmitterAsyncResourceOptions);
+            /**
+             * Call all destroy hooks. This should only ever be called once. An
+             * error will be thrown if it is called more than once. This must be
+             * manually called. If the resource is left to be collected by the GC then
+             * the destroy hooks will never be called.
+             */
+            emitDestroy(): void;
+            /** The unique asyncId assigned to the resource. */
+            readonly asyncId: number;
+            /** The same triggerAsyncId that is passed to the AsyncResource constructor. */
+            readonly triggerAsyncId: number;
+            /** The underlying AsyncResource */
+            readonly asyncResource: EventEmitterReferencingAsyncResource;
+        }
     }
     global {
         namespace NodeJS {
             interface EventEmitter {
+                [EventEmitter.captureRejectionSymbol]?(error: Error, event: string, ...args: any[]): void;
                 /**
                  * Alias for `emitter.on(eventName, listener)`.
                  * @since v0.1.26

node v16.18/ts4.8/http.d.ts

@@ -42,6 +42,7 @@
 declare module "http" {
     import * as stream from "node:stream";
     import { URL } from "node:url";
+    import { EventEmitter } from "node:events";
     import { LookupFunction, Server as NetServer, Socket, TcpSocketConnectOpts } from "node:net";
     // incoming headers will never contain number
     interface IncomingHttpHeaders extends NodeJS.Dict<string | string[]> {
@@ -1216,9 +1217,9 @@ declare module "http" {
      * ```
      * @since v0.3.4
      */
-    class Agent {
+    class Agent extends EventEmitter {
         /**
-         * By default set to 256\. For agents with `keepAlive` enabled, this
+         * By default set to 256. For agents with `keepAlive` enabled, this
          * sets the maximum number of sockets that will be left open in the free
          * state.
          * @since v0.11.7

node v16.18/ts4.8/index.d.ts

@@ -22,7 +22,7 @@
  * IN THE SOFTWARE.
  */
 
-// NOTE: These definitions support NodeJS and TypeScript 4.8 and earlier
+// NOTE: These definitions support NodeJS and TypeScript 4.9+.
 
 // Reference required types from the default lib:
 /// <reference lib="es2020" />

node v16.18/ts4.8/os.d.ts

@@ -28,7 +28,6 @@ declare module "os" {
     }
     interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase {
         family: "IPv4";
-        scopeid?: undefined;
     }
     interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase {
         family: "IPv6";

node v16.18/ts4.8/perf_hooks.d.ts

@@ -30,7 +30,7 @@
  */
 declare module "perf_hooks" {
     import { AsyncResource } from "node:async_hooks";
-    type EntryType = "node" | "mark" | "measure" | "gc" | "function" | "http2" | "http";
+    type EntryType = "node" | "mark" | "measure" | "gc" | "function" | "http2" | "http" | "dns";
     interface NodeGCPerformanceDetail {
         /**
          * When `performanceEntry.entryType` is equal to 'gc', `the performance.kind` property identifies

node v16.18/ts4.8/stream.d.ts

@@ -18,7 +18,7 @@
  */
 declare module "stream" {
     import { Abortable, EventEmitter } from "node:events";
-    import { Blob } from "node:buffer";
+    import { Blob as NodeBlob } from "node:buffer";
     import * as streamPromises from "node:stream/promises";
     import * as streamConsumers from "node:stream/consumers";
     class internal extends EventEmitter {
@@ -45,6 +45,12 @@ declare module "stream" {
             encoding?: BufferEncoding | undefined;
             read?(this: Readable, size: number): void;
         }
+        interface ArrayOptions {
+            /** the maximum concurrent invocations of `fn` to call on the stream at once. **Default: 1**. */
+            concurrency?: number;
+            /** allows destroying the stream if the signal is aborted. */
+            signal?: AbortSignal;
+        }
         /**
          * @since v0.9.4
          */
@@ -397,6 +403,36 @@ declare module "stream" {
              */
             wrap(stream: NodeJS.ReadableStream): this;
             push(chunk: any, encoding?: BufferEncoding): boolean;
+            /**
+             * The iterator created by this method gives users the option to cancel the destruction
+             * of the stream if the `for await...of` loop is exited by `return`, `break`, or `throw`,
+             * or if the iterator should destroy the stream if the stream emitted an error during iteration.
+             * @since v16.3.0
+             * @param options.destroyOnReturn When set to `false`, calling `return` on the async iterator,
+             * or exiting a `for await...of` iteration using a `break`, `return`, or `throw` will not destroy the stream.
+             * **Default: `true`**.
+             */
+            iterator(options?: { destroyOnReturn?: boolean }): AsyncIterableIterator<any>;
+            /**
+             * This method allows mapping over the stream. The *fn* function will be called for every chunk in the stream.
+             * If the *fn* function returns a promise - that promise will be `await`ed before being passed to the result stream.
+             * @since v17.4.0, v16.14.0
+             * @param fn a function to map over every chunk in the stream. Async or not.
+             * @returns a stream mapped with the function *fn*.
+             */
+            map(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => any, options?: ArrayOptions): Readable;
+            /**
+             * This method allows filtering the stream. For each chunk in the stream the *fn* function will be called
+             * and if it returns a truthy value, the chunk will be passed to the result stream.
+             * If the *fn* function returns a promise - that promise will be `await`ed.
+             * @since v17.4.0, v16.14.0
+             * @param fn a function to filter chunks from the stream. Async or not.
+             * @returns a stream filtered with the predicate *fn*.
+             */
+            filter(
+                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
+                options?: ArrayOptions,
+            ): Readable;
             _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
             /**
              * Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'`event (unless `emitClose` is set to `false`). After this call, the readable
@@ -848,7 +884,7 @@ declare module "stream" {
             static from(
                 src:
                     | Stream
-                    | Blob
+                    | NodeBlob
                     | ArrayBuffer
                     | string
                     | Iterable<any>

node v16.18/ts4.8/v8.d.ts

@@ -1,10 +1,10 @@
 /**
- * The `v8` module exposes APIs that are specific to the version of [V8](https://developers.google.com/v8/) built into the Node.js binary. It can be accessed using:
+ * The `node:v8` module exposes APIs that are specific to the version of [V8](https://developers.google.com/v8/) built into the Node.js binary. It can be accessed using:
  *
  * ```js
- * const v8 = require('v8');
+ * const v8 = require('node:v8');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/v8.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.20.2/lib/v8.js)
  */
 declare module "v8" {
     import { Readable } from "node:stream";
@@ -29,6 +29,9 @@ declare module "v8" {
         does_zap_garbage: DoesZapCodeSpaceFlag;
         number_of_native_contexts: number;
         number_of_detached_contexts: number;
+        total_global_handles_size: number;
+        used_global_handles_size: number;
+        external_memory: number;
     }
     interface HeapCodeStatistics {
         code_and_metadata_size: number;
@@ -68,6 +71,15 @@ declare module "v8" {
      * of contexts that were detached and not yet garbage collected. This number
      * being non-zero indicates a potential memory leak.
      *
+     * `total_global_handles_size` The value of total\_global\_handles\_size is the
+     * total memory size of V8 global handles.
+     *
+     * `used_global_handles_size` The value of used\_global\_handles\_size is the
+     * used memory size of V8 global handles.
+     *
+     * `external_memory` The value of external\_memory is the memory size of array
+     * buffers and external strings.
+     *
      * ```js
      * {
      *   total_heap_size: 7326976,
@@ -80,7 +92,10 @@ declare module "v8" {
      *   peak_malloced_memory: 1127496,
      *   does_zap_garbage: 0,
      *   number_of_native_contexts: 1,
-     *   number_of_detached_contexts: 0
+     *   number_of_detached_contexts: 0,
+     *   total_global_handles_size: 8192,
+     *   used_global_handles_size: 3296,
+     *   external_memory: 318824
      * }
      * ```
      * @since v1.0.0
@@ -90,7 +105,7 @@ declare module "v8" {
      * Returns statistics about the V8 heap spaces, i.e. the segments which make up
      * the V8 heap. Neither the ordering of heap spaces, nor the availability of a
      * heap space can be guaranteed as the statistics are provided via the
-     * V8[`GetHeapSpaceStatistics`](https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#ac673576f24fdc7a33378f8f57e1d13a4) function and may change from one V8 version to the
+     * V8 [`GetHeapSpaceStatistics`](https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#ac673576f24fdc7a33378f8f57e1d13a4) function and may change from one V8 version to the
      * next.
      *
      * The value returned is an array of objects containing the following properties:
@@ -149,7 +164,7 @@ declare module "v8" {
      *
      * ```js
      * // Print GC events to stdout for one minute.
-     * const v8 = require('v8');
+     * const v8 = require('node:v8');
      * v8.setFlagsFromString('--trace_gc');
      * setTimeout(() => { v8.setFlagsFromString('--notrace_gc'); }, 60e3);
      * ```
@@ -163,9 +178,16 @@ declare module "v8" {
      * Chrome DevTools. The JSON schema is undocumented and specific to the
      * V8 engine. Therefore, the schema may change from one version of V8 to the next.
      *
+     * Creating a heap snapshot requires memory about twice the size of the heap at
+     * the time the snapshot is created. This results in the risk of OOM killers
+     * terminating the process.
+     *
+     * Generating a snapshot is a synchronous operation which blocks the event loop
+     * for a duration depending on the heap size.
+     *
      * ```js
      * // Print heap snapshot to the console
-     * const v8 = require('v8');
+     * const v8 = require('node:v8');
      * const stream = v8.getHeapSnapshot();
      * stream.pipe(process.stdout);
      * ```
@@ -182,13 +204,20 @@ declare module "v8" {
      * A heap snapshot is specific to a single V8 isolate. When using `worker threads`, a heap snapshot generated from the main thread will
      * not contain any information about the workers, and vice versa.
      *
+     * Creating a heap snapshot requires memory about twice the size of the heap at
+     * the time the snapshot is created. This results in the risk of OOM killers
+     * terminating the process.
+     *
+     * Generating a snapshot is a synchronous operation which blocks the event loop
+     * for a duration depending on the heap size.
+     *
      * ```js
-     * const { writeHeapSnapshot } = require('v8');
+     * const { writeHeapSnapshot } = require('node:v8');
      * const {
      *   Worker,
      *   isMainThread,
-     *   parentPort
-     * } = require('worker_threads');
+     *   parentPort,
+     * } = require('node:worker_threads');
      *
      * if (isMainThread) {
      *   const worker = new Worker(__filename);
@@ -219,13 +248,16 @@ declare module "v8" {
      */
     function writeHeapSnapshot(filename?: string): string;
     /**
-     * Returns an object with the following properties:
+     * Get statistics about code and its metadata in the heap, see
+     * V8 [`GetHeapCodeAndMetadataStatistics`](https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#a6079122af17612ef54ef3348ce170866) API. Returns an object with the
+     * following properties:
      *
      * ```js
      * {
      *   code_and_metadata_size: 212208,
      *   bytecode_and_metadata_size: 161368,
-     *   external_script_source_size: 1410794
+     *   external_script_source_size: 1410794,
+     *   cpu_profiler_metadata_size: 0,
      * }
      * ```
      * @since v12.8.0
@@ -275,7 +307,7 @@ declare module "v8" {
          */
         writeDouble(value: number): void;
         /**
-         * Write raw bytes into the serializer’s internal buffer. The deserializer
+         * Write raw bytes into the serializer's internal buffer. The deserializer
          * will require a way to compute the length of the buffer.
          * For use inside of a custom `serializer._writeHostObject()`.
          */
@@ -331,7 +363,7 @@ declare module "v8" {
          */
         readDouble(): number;
         /**
-         * Read raw bytes from the deserializer’s internal buffer. The `length` parameter
+         * Read raw bytes from the deserializer's internal buffer. The `length` parameter
          * must correspond to the length of the buffer that was passed to `serializer.writeRawBytes()`.
          * For use inside of a custom `deserializer._readHostObject()`.
          */
@@ -344,6 +376,10 @@ declare module "v8" {
     class DefaultDeserializer extends Deserializer {}
     /**
      * Uses a `DefaultSerializer` to serialize `value` into a buffer.
+     *
+     * `ERR_BUFFER_TOO_LARGE` will be thrown when trying to
+     * serialize a huge object which requires buffer
+     * larger than `buffer.constants.MAX_LENGTH`.
      * @since v8.0.0
      */
     function serialize(value: any): Buffer;
@@ -362,20 +398,27 @@ declare module "v8" {
      *
      * When the process is about to exit, one last coverage will still be written to
      * disk unless {@link stopCoverage} is invoked before the process exits.
-     * @since v15.1.0, v12.22.0
+     * @since v15.1.0, v14.18.0, v12.22.0
      */
     function takeCoverage(): void;
     /**
      * The `v8.stopCoverage()` method allows the user to stop the coverage collection
      * started by `NODE_V8_COVERAGE`, so that V8 can release the execution count
      * records and optimize code. This can be used in conjunction with {@link takeCoverage} if the user wants to collect the coverage on demand.
-     * @since v15.1.0, v12.22.0
+     * @since v15.1.0, v14.18.0, v12.22.0
      */
     function stopCoverage(): void;
+    /**
+     * The API is a no-op if `--heapsnapshot-near-heap-limit` is already set from the command line or the API is called more than once.
+     * `limit` must be a positive integer. See [`--heapsnapshot-near-heap-limit`](https://nodejs.org/docs/latest-v16.x/api/cli.html#--heapsnapshot-near-heap-limitmax_count) for more information.
+     * @experimental
+     * @since v16.18.0
+     */
+    function setHeapSnapshotNearHeapLimit(limit: number): void;
     /**
      * Called when a promise is constructed. This does not mean that corresponding before/after events will occur, only that the possibility exists. This will
      * happen if a promise is created without ever getting a continuation.
-     * @since v17.1.0, v16.14.0
+     * @since v16.14.0
      * @param promise The promise being created.
      * @param parent The promise continued from, if applicable.
      */
@@ -387,14 +430,14 @@ declare module "v8" {
      *
      * The before callback will be called 0 to N times. The before callback will typically be called 0 times if no continuation was ever made for the promise.
      * The before callback may be called many times in the case where many continuations have been made from the same promise.
-     * @since v17.1.0, v16.14.0
+     * @since v16.14.0
      */
     interface Before {
         (promise: Promise<unknown>): void;
     }
     /**
      * Called immediately after a promise continuation executes. This may be after a `then()`, `catch()`, or `finally()` handler or before an await after another await.
-     * @since v17.1.0, v16.14.0
+     * @since v16.14.0
      */
     interface After {
         (promise: Promise<unknown>): void;
@@ -402,7 +445,7 @@ declare module "v8" {
     /**
      * Called when the promise receives a resolution or rejection value. This may occur synchronously in the case of {@link Promise.resolve()} or
      * {@link Promise.reject()}.
-     * @since v17.1.0, v16.14.0
+     * @since v16.14.0
      */
     interface Settled {
         (promise: Promise<unknown>): void;
@@ -413,7 +456,7 @@ declare module "v8" {
      *
      * Because promises are asynchronous resources whose lifecycle is tracked via the promise hooks mechanism, the `init()`, `before()`, `after()`, and
      * `settled()` callbacks must not be async functions as they create more promises which would produce an infinite loop.
-     * @since v17.1.0, v16.14.0
+     * @since v16.14.0
      */
     interface HookCallbacks {
         init?: Init;
@@ -424,28 +467,28 @@ declare module "v8" {
     interface PromiseHooks {
         /**
          * The `init` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
-         * @since v17.1.0, v16.14.0
+         * @since v16.14.0
          * @param init The {@link Init | `init` callback} to call when a promise is created.
          * @return Call to stop the hook.
          */
         onInit: (init: Init) => Function;
         /**
          * The `settled` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
-         * @since v17.1.0, v16.14.0
+         * @since v16.14.0
          * @param settled The {@link Settled | `settled` callback} to call when a promise is created.
          * @return Call to stop the hook.
          */
         onSettled: (settled: Settled) => Function;
         /**
          * The `before` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
-         * @since v17.1.0, v16.14.0
+         * @since v16.14.0
          * @param before The {@link Before | `before` callback} to call before a promise continuation executes.
          * @return Call to stop the hook.
          */
         onBefore: (before: Before) => Function;
         /**
          * The `after` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
-         * @since v17.1.0, v16.14.0
+         * @since v16.14.0
          * @param after The {@link After | `after` callback} to call after a promise continuation executes.
          * @return Call to stop the hook.
          */
@@ -455,7 +498,7 @@ declare module "v8" {
          * The callbacks `init()`/`before()`/`after()`/`settled()` are called for the respective events during a promise's lifetime.
          * All callbacks are optional. For example, if only promise creation needs to be tracked, then only the init callback needs to be passed.
          * The hook callbacks must be plain functions. Providing async functions will throw as it would produce an infinite microtask loop.
-         * @since v17.1.0, v16.14.0
+         * @since v16.14.0
          * @param callbacks The {@link HookCallbacks | Hook Callbacks} to register
          * @return Used for disabling hooks
          */
@@ -463,9 +506,120 @@ declare module "v8" {
     }
     /**
      * The `promiseHooks` interface can be used to track promise lifecycle events.
-     * @since v17.1.0, v16.14.0
+     * @since v16.14.0
      */
     const promiseHooks: PromiseHooks;
+    type StartupSnapshotCallbackFn = (args: any) => any;
+    interface StartupSnapshot {
+        /**
+         * Add a callback that will be called when the Node.js instance is about to get serialized into a snapshot and exit.
+         * This can be used to release resources that should not or cannot be serialized or to convert user data into a form more suitable for serialization.
+         * @since v16.17.0
+         */
+        addSerializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void;
+        /**
+         * Add a callback that will be called when the Node.js instance is deserialized from a snapshot.
+         * The `callback` and the `data` (if provided) will be serialized into the snapshot, they can be used to re-initialize the state of the application or
+         * to re-acquire resources that the application needs when the application is restarted from the snapshot.
+         * @since v16.17.0
+         */
+        addDeserializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void;
+        /**
+         * This sets the entry point of the Node.js application when it is deserialized from a snapshot. This can be called only once in the snapshot building script.
+         * If called, the deserialized application no longer needs an additional entry point script to start up and will simply invoke the callback along with the deserialized
+         * data (if provided), otherwise an entry point script still needs to be provided to the deserialized application.
+         * @since v16.17.0
+         */
+        setDeserializeMainFunction(callback: StartupSnapshotCallbackFn, data?: any): void;
+        /**
+         * Returns true if the Node.js instance is run to build a snapshot.
+         * @since v16.17.0
+         */
+        isBuildingSnapshot(): boolean;
+    }
+    /**
+     * The `v8.startupSnapshot` interface can be used to add serialization and deserialization hooks for custom startup snapshots.
+     *
+     * ```bash
+     * $ node --snapshot-blob snapshot.blob --build-snapshot entry.js
+     * # This launches a process with the snapshot
+     * $ node --snapshot-blob snapshot.blob
+     * ```
+     *
+     * In the example above, `entry.js` can use methods from the `v8.startupSnapshot` interface to specify how to save information for custom objects
+     * in the snapshot during serialization
+     * and how the information can be used to synchronize these objects during deserialization of the snapshot.
+     * For example, if the `entry.js` contains the following script:
+     *
+     * ```js
+     * 'use strict';
+     *
+     * const fs = require('node:fs');
+     * const zlib = require('node:zlib');
+     * const path = require('node:path');
+     * const assert = require('node:assert');
+     *
+     * const v8 = require('node:v8');
+     *
+     * class BookShelf {
+     *   storage = new Map();
+     *
+     *   // Reading a series of files from directory and store them into storage.
+     *   constructor(directory, books) {
+     *     for (const book of books) {
+     *       this.storage.set(book, fs.readFileSync(path.join(directory, book)));
+     *     }
+     *   }
+     *
+     *   static compressAll(shelf) {
+     *     for (const [ book, content ] of shelf.storage) {
+     *       shelf.storage.set(book, zlib.gzipSync(content));
+     *     }
+     *   }
+     *
+     *   static decompressAll(shelf) {
+     *     for (const [ book, content ] of shelf.storage) {
+     *       shelf.storage.set(book, zlib.gunzipSync(content));
+     *     }
+     *   }
+     * }
+     *
+     * // __dirname here is where the snapshot script is placed
+     * // during snapshot building time.
+     * const shelf = new BookShelf(__dirname, [
+     *   'book1.en_US.txt',
+     *   'book1.es_ES.txt',
+     *   'book2.zh_CN.txt',
+     * ]);
+     *
+     * assert(v8.startupSnapshot.isBuildingSnapshot());
+     * // On snapshot serialization, compress the books to reduce size.
+     * v8.startupSnapshot.addSerializeCallback(BookShelf.compressAll, shelf);
+     * // On snapshot deserialization, decompress the books.
+     * v8.startupSnapshot.addDeserializeCallback(BookShelf.decompressAll, shelf);
+     * v8.startupSnapshot.setDeserializeMainFunction((shelf) => {
+     *   // process.env and process.argv are refreshed during snapshot
+     *   // deserialization.
+     *   const lang = process.env.BOOK_LANG || 'en_US';
+     *   const book = process.argv[1];
+     *   const name = `${book}.${lang}.txt`;
+     *   console.log(shelf.storage.get(name));
+     * }, shelf);
+     * ```
+     *
+     * The resulted binary will get print the data deserialized from the snapshot during start up, using the refreshed `process.env` and `process.argv` of the launched process:
+     *
+     * ```bash
+     * $ BOOK_LANG=es_ES node --snapshot-blob snapshot.blob book1
+     * # Prints content of book1.es_ES.txt deserialized from the snapshot.
+     * ```
+     *
+     * Currently the application deserialized from a user-land snapshot cannot be snapshotted again, so these APIs are only available to applications that are not deserialized from a user-land snapshot.
+     *
+     * @experimental
+     * @since v16.17.0
+     */
+    const startupSnapshot: StartupSnapshot;
 }
 declare module "node:v8" {
     export * from "v8";

node v16.18/v8.d.ts

@@ -1,10 +1,10 @@
 /**
- * The `v8` module exposes APIs that are specific to the version of [V8](https://developers.google.com/v8/) built into the Node.js binary. It can be accessed using:
+ * The `node:v8` module exposes APIs that are specific to the version of [V8](https://developers.google.com/v8/) built into the Node.js binary. It can be accessed using:
  *
  * ```js
- * const v8 = require('v8');
+ * const v8 = require('node:v8');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/v8.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.20.2/lib/v8.js)
  */
 declare module "v8" {
     import { Readable } from "node:stream";
@@ -29,6 +29,9 @@ declare module "v8" {
         does_zap_garbage: DoesZapCodeSpaceFlag;
         number_of_native_contexts: number;
         number_of_detached_contexts: number;
+        total_global_handles_size: number;
+        used_global_handles_size: number;
+        external_memory: number;
     }
     interface HeapCodeStatistics {
         code_and_metadata_size: number;
@@ -68,6 +71,15 @@ declare module "v8" {
      * of contexts that were detached and not yet garbage collected. This number
      * being non-zero indicates a potential memory leak.
      *
+     * `total_global_handles_size` The value of total\_global\_handles\_size is the
+     * total memory size of V8 global handles.
+     *
+     * `used_global_handles_size` The value of used\_global\_handles\_size is the
+     * used memory size of V8 global handles.
+     *
+     * `external_memory` The value of external\_memory is the memory size of array
+     * buffers and external strings.
+     *
      * ```js
      * {
      *   total_heap_size: 7326976,
@@ -80,7 +92,10 @@ declare module "v8" {
      *   peak_malloced_memory: 1127496,
      *   does_zap_garbage: 0,
      *   number_of_native_contexts: 1,
-     *   number_of_detached_contexts: 0
+     *   number_of_detached_contexts: 0,
+     *   total_global_handles_size: 8192,
+     *   used_global_handles_size: 3296,
+     *   external_memory: 318824
      * }
      * ```
      * @since v1.0.0
@@ -90,7 +105,7 @@ declare module "v8" {
      * Returns statistics about the V8 heap spaces, i.e. the segments which make up
      * the V8 heap. Neither the ordering of heap spaces, nor the availability of a
      * heap space can be guaranteed as the statistics are provided via the
-     * V8[`GetHeapSpaceStatistics`](https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#ac673576f24fdc7a33378f8f57e1d13a4) function and may change from one V8 version to the
+     * V8 [`GetHeapSpaceStatistics`](https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#ac673576f24fdc7a33378f8f57e1d13a4) function and may change from one V8 version to the
      * next.
      *
      * The value returned is an array of objects containing the following properties:
@@ -149,7 +164,7 @@ declare module "v8" {
      *
      * ```js
      * // Print GC events to stdout for one minute.
-     * const v8 = require('v8');
+     * const v8 = require('node:v8');
      * v8.setFlagsFromString('--trace_gc');
      * setTimeout(() => { v8.setFlagsFromString('--notrace_gc'); }, 60e3);
      * ```
@@ -163,9 +178,16 @@ declare module "v8" {
      * Chrome DevTools. The JSON schema is undocumented and specific to the
      * V8 engine. Therefore, the schema may change from one version of V8 to the next.
      *
+     * Creating a heap snapshot requires memory about twice the size of the heap at
+     * the time the snapshot is created. This results in the risk of OOM killers
+     * terminating the process.
+     *
+     * Generating a snapshot is a synchronous operation which blocks the event loop
+     * for a duration depending on the heap size.
+     *
      * ```js
      * // Print heap snapshot to the console
-     * const v8 = require('v8');
+     * const v8 = require('node:v8');
      * const stream = v8.getHeapSnapshot();
      * stream.pipe(process.stdout);
      * ```
@@ -182,13 +204,20 @@ declare module "v8" {
      * A heap snapshot is specific to a single V8 isolate. When using `worker threads`, a heap snapshot generated from the main thread will
      * not contain any information about the workers, and vice versa.
      *
+     * Creating a heap snapshot requires memory about twice the size of the heap at
+     * the time the snapshot is created. This results in the risk of OOM killers
+     * terminating the process.
+     *
+     * Generating a snapshot is a synchronous operation which blocks the event loop
+     * for a duration depending on the heap size.
+     *
      * ```js
-     * const { writeHeapSnapshot } = require('v8');
+     * const { writeHeapSnapshot } = require('node:v8');
      * const {
      *   Worker,
      *   isMainThread,
-     *   parentPort
-     * } = require('worker_threads');
+     *   parentPort,
+     * } = require('node:worker_threads');
      *
      * if (isMainThread) {
      *   const worker = new Worker(__filename);
@@ -219,13 +248,16 @@ declare module "v8" {
      */
     function writeHeapSnapshot(filename?: string): string;
     /**
-     * Returns an object with the following properties:
+     * Get statistics about code and its metadata in the heap, see
+     * V8 [`GetHeapCodeAndMetadataStatistics`](https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#a6079122af17612ef54ef3348ce170866) API. Returns an object with the
+     * following properties:
      *
      * ```js
      * {
      *   code_and_metadata_size: 212208,
      *   bytecode_and_metadata_size: 161368,
-     *   external_script_source_size: 1410794
+     *   external_script_source_size: 1410794,
+     *   cpu_profiler_metadata_size: 0,
      * }
      * ```
      * @since v12.8.0
@@ -275,7 +307,7 @@ declare module "v8" {
          */
         writeDouble(value: number): void;
         /**
-         * Write raw bytes into the serializer’s internal buffer. The deserializer
+         * Write raw bytes into the serializer's internal buffer. The deserializer
          * will require a way to compute the length of the buffer.
          * For use inside of a custom `serializer._writeHostObject()`.
          */
@@ -331,7 +363,7 @@ declare module "v8" {
          */
         readDouble(): number;
         /**
-         * Read raw bytes from the deserializer’s internal buffer. The `length` parameter
+         * Read raw bytes from the deserializer's internal buffer. The `length` parameter
          * must correspond to the length of the buffer that was passed to `serializer.writeRawBytes()`.
          * For use inside of a custom `deserializer._readHostObject()`.
          */
@@ -344,6 +376,10 @@ declare module "v8" {
     class DefaultDeserializer extends Deserializer {}
     /**
      * Uses a `DefaultSerializer` to serialize `value` into a buffer.
+     *
+     * `ERR_BUFFER_TOO_LARGE` will be thrown when trying to
+     * serialize a huge object which requires buffer
+     * larger than `buffer.constants.MAX_LENGTH`.
      * @since v8.0.0
      */
     function serialize(value: any): Buffer;
@@ -362,20 +398,27 @@ declare module "v8" {
      *
      * When the process is about to exit, one last coverage will still be written to
      * disk unless {@link stopCoverage} is invoked before the process exits.
-     * @since v15.1.0, v12.22.0
+     * @since v15.1.0, v14.18.0, v12.22.0
      */
     function takeCoverage(): void;
     /**
      * The `v8.stopCoverage()` method allows the user to stop the coverage collection
      * started by `NODE_V8_COVERAGE`, so that V8 can release the execution count
      * records and optimize code. This can be used in conjunction with {@link takeCoverage} if the user wants to collect the coverage on demand.
-     * @since v15.1.0, v12.22.0
+     * @since v15.1.0, v14.18.0, v12.22.0
      */
     function stopCoverage(): void;
+    /**
+     * The API is a no-op if `--heapsnapshot-near-heap-limit` is already set from the command line or the API is called more than once.
+     * `limit` must be a positive integer. See [`--heapsnapshot-near-heap-limit`](https://nodejs.org/docs/latest-v16.x/api/cli.html#--heapsnapshot-near-heap-limitmax_count) for more information.
+     * @experimental
+     * @since v16.18.0
+     */
+    function setHeapSnapshotNearHeapLimit(limit: number): void;
     /**
      * Called when a promise is constructed. This does not mean that corresponding before/after events will occur, only that the possibility exists. This will
      * happen if a promise is created without ever getting a continuation.
-     * @since v17.1.0, v16.14.0
+     * @since v16.14.0
      * @param promise The promise being created.
      * @param parent The promise continued from, if applicable.
      */
@@ -387,14 +430,14 @@ declare module "v8" {
      *
      * The before callback will be called 0 to N times. The before callback will typically be called 0 times if no continuation was ever made for the promise.
      * The before callback may be called many times in the case where many continuations have been made from the same promise.
-     * @since v17.1.0, v16.14.0
+     * @since v16.14.0
      */
     interface Before {
         (promise: Promise<unknown>): void;
     }
     /**
      * Called immediately after a promise continuation executes. This may be after a `then()`, `catch()`, or `finally()` handler or before an await after another await.
-     * @since v17.1.0, v16.14.0
+     * @since v16.14.0
      */
     interface After {
         (promise: Promise<unknown>): void;
@@ -402,7 +445,7 @@ declare module "v8" {
     /**
      * Called when the promise receives a resolution or rejection value. This may occur synchronously in the case of {@link Promise.resolve()} or
      * {@link Promise.reject()}.
-     * @since v17.1.0, v16.14.0
+     * @since v16.14.0
      */
     interface Settled {
         (promise: Promise<unknown>): void;
@@ -413,7 +456,7 @@ declare module "v8" {
      *
      * Because promises are asynchronous resources whose lifecycle is tracked via the promise hooks mechanism, the `init()`, `before()`, `after()`, and
      * `settled()` callbacks must not be async functions as they create more promises which would produce an infinite loop.
-     * @since v17.1.0, v16.14.0
+     * @since v16.14.0
      */
     interface HookCallbacks {
         init?: Init;
@@ -424,28 +467,28 @@ declare module "v8" {
     interface PromiseHooks {
         /**
          * The `init` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
-         * @since v17.1.0, v16.14.0
+         * @since v16.14.0
          * @param init The {@link Init | `init` callback} to call when a promise is created.
          * @return Call to stop the hook.
          */
         onInit: (init: Init) => Function;
         /**
          * The `settled` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
-         * @since v17.1.0, v16.14.0
+         * @since v16.14.0
          * @param settled The {@link Settled | `settled` callback} to call when a promise is created.
          * @return Call to stop the hook.
          */
         onSettled: (settled: Settled) => Function;
         /**
          * The `before` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
-         * @since v17.1.0, v16.14.0
+         * @since v16.14.0
          * @param before The {@link Before | `before` callback} to call before a promise continuation executes.
          * @return Call to stop the hook.
          */
         onBefore: (before: Before) => Function;
         /**
          * The `after` hook must be a plain function. Providing an async function will throw as it would produce an infinite microtask loop.
-         * @since v17.1.0, v16.14.0
+         * @since v16.14.0
          * @param after The {@link After | `after` callback} to call after a promise continuation executes.
          * @return Call to stop the hook.
          */
@@ -455,7 +498,7 @@ declare module "v8" {
          * The callbacks `init()`/`before()`/`after()`/`settled()` are called for the respective events during a promise's lifetime.
          * All callbacks are optional. For example, if only promise creation needs to be tracked, then only the init callback needs to be passed.
          * The hook callbacks must be plain functions. Providing async functions will throw as it would produce an infinite microtask loop.
-         * @since v17.1.0, v16.14.0
+         * @since v16.14.0
          * @param callbacks The {@link HookCallbacks | Hook Callbacks} to register
          * @return Used for disabling hooks
          */
@@ -463,9 +506,120 @@ declare module "v8" {
     }
     /**
      * The `promiseHooks` interface can be used to track promise lifecycle events.
-     * @since v17.1.0, v16.14.0
+     * @since v16.14.0
      */
     const promiseHooks: PromiseHooks;
+    type StartupSnapshotCallbackFn = (args: any) => any;
+    interface StartupSnapshot {
+        /**
+         * Add a callback that will be called when the Node.js instance is about to get serialized into a snapshot and exit.
+         * This can be used to release resources that should not or cannot be serialized or to convert user data into a form more suitable for serialization.
+         * @since v16.17.0
+         */
+        addSerializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void;
+        /**
+         * Add a callback that will be called when the Node.js instance is deserialized from a snapshot.
+         * The `callback` and the `data` (if provided) will be serialized into the snapshot, they can be used to re-initialize the state of the application or
+         * to re-acquire resources that the application needs when the application is restarted from the snapshot.
+         * @since v16.17.0
+         */
+        addDeserializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void;
+        /**
+         * This sets the entry point of the Node.js application when it is deserialized from a snapshot. This can be called only once in the snapshot building script.
+         * If called, the deserialized application no longer needs an additional entry point script to start up and will simply invoke the callback along with the deserialized
+         * data (if provided), otherwise an entry point script still needs to be provided to the deserialized application.
+         * @since v16.17.0
+         */
+        setDeserializeMainFunction(callback: StartupSnapshotCallbackFn, data?: any): void;
+        /**
+         * Returns true if the Node.js instance is run to build a snapshot.
+         * @since v16.17.0
+         */
+        isBuildingSnapshot(): boolean;
+    }
+    /**
+     * The `v8.startupSnapshot` interface can be used to add serialization and deserialization hooks for custom startup snapshots.
+     *
+     * ```bash
+     * $ node --snapshot-blob snapshot.blob --build-snapshot entry.js
+     * # This launches a process with the snapshot
+     * $ node --snapshot-blob snapshot.blob
+     * ```
+     *
+     * In the example above, `entry.js` can use methods from the `v8.startupSnapshot` interface to specify how to save information for custom objects
+     * in the snapshot during serialization
+     * and how the information can be used to synchronize these objects during deserialization of the snapshot.
+     * For example, if the `entry.js` contains the following script:
+     *
+     * ```js
+     * 'use strict';
+     *
+     * const fs = require('node:fs');
+     * const zlib = require('node:zlib');
+     * const path = require('node:path');
+     * const assert = require('node:assert');
+     *
+     * const v8 = require('node:v8');
+     *
+     * class BookShelf {
+     *   storage = new Map();
+     *
+     *   // Reading a series of files from directory and store them into storage.
+     *   constructor(directory, books) {
+     *     for (const book of books) {
+     *       this.storage.set(book, fs.readFileSync(path.join(directory, book)));
+     *     }
+     *   }
+     *
+     *   static compressAll(shelf) {
+     *     for (const [ book, content ] of shelf.storage) {
+     *       shelf.storage.set(book, zlib.gzipSync(content));
+     *     }
+     *   }
+     *
+     *   static decompressAll(shelf) {
+     *     for (const [ book, content ] of shelf.storage) {
+     *       shelf.storage.set(book, zlib.gunzipSync(content));
+     *     }
+     *   }
+     * }
+     *
+     * // __dirname here is where the snapshot script is placed
+     * // during snapshot building time.
+     * const shelf = new BookShelf(__dirname, [
+     *   'book1.en_US.txt',
+     *   'book1.es_ES.txt',
+     *   'book2.zh_CN.txt',
+     * ]);
+     *
+     * assert(v8.startupSnapshot.isBuildingSnapshot());
+     * // On snapshot serialization, compress the books to reduce size.
+     * v8.startupSnapshot.addSerializeCallback(BookShelf.compressAll, shelf);
+     * // On snapshot deserialization, decompress the books.
+     * v8.startupSnapshot.addDeserializeCallback(BookShelf.decompressAll, shelf);
+     * v8.startupSnapshot.setDeserializeMainFunction((shelf) => {
+     *   // process.env and process.argv are refreshed during snapshot
+     *   // deserialization.
+     *   const lang = process.env.BOOK_LANG || 'en_US';
+     *   const book = process.argv[1];
+     *   const name = `${book}.${lang}.txt`;
+     *   console.log(shelf.storage.get(name));
+     * }, shelf);
+     * ```
+     *
+     * The resulted binary will get print the data deserialized from the snapshot during start up, using the refreshed `process.env` and `process.argv` of the launched process:
+     *
+     * ```bash
+     * $ BOOK_LANG=es_ES node --snapshot-blob snapshot.blob book1
+     * # Prints content of book1.es_ES.txt deserialized from the snapshot.
+     * ```
+     *
+     * Currently the application deserialized from a user-land snapshot cannot be snapshotted again, so these APIs are only available to applications that are not deserialized from a user-land snapshot.
+     *
+     * @experimental
+     * @since v16.17.0
+     */
+    const startupSnapshot: StartupSnapshot;
 }
 declare module "node:v8" {
     export * from "v8";