@types/node 20.10.7 → 20.11.0

node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Sun, 07 Jan 2024 15:35:36 GMT
+ * Last updated: Thu, 11 Jan 2024 05:35:20 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

node/buffer.d.ts

@@ -564,7 +564,7 @@ declare module "buffer" {
              *
              * The `Buffer` module pre-allocates an internal `Buffer` instance of
              * size `Buffer.poolSize` that is used as a pool for the fast allocation of new`Buffer` instances created using `Buffer.allocUnsafe()`, `Buffer.from(array)`,
-             * and `Buffer.concat()` only when `size` is less than or equal to`Buffer.poolSize >> 1` (floor of `Buffer.poolSize` divided by two).
+             * and `Buffer.concat()` only when `size` is less than`Buffer.poolSize >>> 1` (floor of `Buffer.poolSize` divided by two).
              *
              * Use of this pre-allocated internal memory pool is a key difference between
              * calling `Buffer.alloc(size, fill)` vs. `Buffer.allocUnsafe(size).fill(fill)`.

node/crypto.d.ts

@@ -638,9 +638,10 @@ declare module "crypto" {
         export(options?: KeyExportOptions<"der">): Buffer;
         export(options?: JwkKeyExportOptions): JsonWebKey;
         /**
-         * Returns `true` or `false` depending on whether the keys have exactly the same type, value, and parameters.
-         * This method is not [constant time](https://en.wikipedia.org/wiki/Timing_attack).
-         * @since v16.15.0
+         * Returns `true` or `false` depending on whether the keys have exactly the same
+         * type, value, and parameters. This method is not [constant time](https://en.wikipedia.org/wiki/Timing_attack).
+         * @since v17.7.0, v16.15.0
+         * @param otherKeyObject A `KeyObject` with which to compare `keyObject`.
          */
         equals(otherKeyObject: KeyObject): boolean;
         /**

node/dgram.d.ts

@@ -228,13 +228,13 @@ declare module "dgram" {
          */
         getSendBufferSize(): number;
         /**
-         * @since v18.8.0,v16.19.0
-         * @return the number of bytes queued for sending.
+         * @since v18.8.0, v16.19.0
+         * @return Number of bytes queued for sending.
          */
         getSendQueueSize(): number;
         /**
-         * @since v18.8.0,v16.19.0
-         * @return the number of send requests currently in the queue awaiting to be processed.
+         * @since v18.8.0, v16.19.0
+         * @return Number of send requests currently in the queue awaiting to be processed.
          */
         getSendQueueCount(): number;
         /**

node/diagnostics_channel.d.ts

@@ -23,6 +23,7 @@
  * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/diagnostics_channel.js)
  */
 declare module "diagnostics_channel" {
+    import { AsyncLocalStorage } from "node:async_hooks";
     /**
      * Check if there are active subscribers to the named channel. This is helpful if
      * the message you want to send might be expensive to prepare.
@@ -95,6 +96,36 @@ declare module "diagnostics_channel" {
      * @return `true` if the handler was found, `false` otherwise.
      */
     function unsubscribe(name: string | symbol, onMessage: ChannelListener): boolean;
+    /**
+     * Creates a `TracingChannel` wrapper for the given `TracingChannel Channels`. If a name is given, the corresponding tracing
+     * channels will be created in the form of `tracing:${name}:${eventType}` where`eventType` corresponds to the types of `TracingChannel Channels`.
+     *
+     * ```js
+     * import diagnostics_channel from 'node:diagnostics_channel';
+     *
+     * const channelsByName = diagnostics_channel.tracingChannel('my-channel');
+     *
+     * // or...
+     *
+     * const channelsByCollection = diagnostics_channel.tracingChannel({
+     *   start: diagnostics_channel.channel('tracing:my-channel:start'),
+     *   end: diagnostics_channel.channel('tracing:my-channel:end'),
+     *   asyncStart: diagnostics_channel.channel('tracing:my-channel:asyncStart'),
+     *   asyncEnd: diagnostics_channel.channel('tracing:my-channel:asyncEnd'),
+     *   error: diagnostics_channel.channel('tracing:my-channel:error'),
+     * });
+     * ```
+     * @since v19.9.0
+     * @experimental
+     * @param nameOrChannels Channel name or object containing all the `TracingChannel Channels`
+     * @return Collection of channels to trace with
+     */
+    function tracingChannel<
+        StoreType = unknown,
+        ContextType extends object = StoreType extends object ? StoreType : object,
+    >(
+        nameOrChannels: string | TracingChannelCollection<StoreType, ContextType>,
+    ): TracingChannel<StoreType, ContextType>;
     /**
      * The class `Channel` represents an individual named channel within the data
      * pipeline. It is used to track subscribers and to publish messages when there
@@ -104,7 +135,7 @@ declare module "diagnostics_channel" {
      * with `new Channel(name)` is not supported.
      * @since v15.1.0, v14.17.0
      */
-    class Channel {
+    class Channel<StoreType = unknown, ContextType = StoreType> {
         readonly name: string | symbol;
         /**
          * Check if there are active subscribers to this channel. This is helpful if
@@ -184,6 +215,329 @@ declare module "diagnostics_channel" {
          * @return `true` if the handler was found, `false` otherwise.
          */
         unsubscribe(onMessage: ChannelListener): void;
+        /**
+         * When `channel.runStores(context, ...)` is called, the given context data
+         * will be applied to any store bound to the channel. If the store has already been
+         * bound the previous `transform` function will be replaced with the new one.
+         * The `transform` function may be omitted to set the given context data as the
+         * context directly.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const store = new AsyncLocalStorage();
+         *
+         * const channel = diagnostics_channel.channel('my-channel');
+         *
+         * channel.bindStore(store, (data) => {
+         *   return { data };
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param store The store to which to bind the context data
+         * @param transform Transform context data before setting the store context
+         */
+        bindStore(store: AsyncLocalStorage<StoreType>, transform?: (context: ContextType) => StoreType): void;
+        /**
+         * Remove a message handler previously registered to this channel with `channel.bindStore(store)`.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const store = new AsyncLocalStorage();
+         *
+         * const channel = diagnostics_channel.channel('my-channel');
+         *
+         * channel.bindStore(store);
+         * channel.unbindStore(store);
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param store The store to unbind from the channel.
+         * @return `true` if the store was found, `false` otherwise.
+         */
+        unbindStore(store: any): void;
+        /**
+         * Applies the given data to any AsyncLocalStorage instances bound to the channel
+         * for the duration of the given function, then publishes to the channel within
+         * the scope of that data is applied to the stores.
+         *
+         * If a transform function was given to `channel.bindStore(store)` it will be
+         * applied to transform the message data before it becomes the context value for
+         * the store. The prior storage context is accessible from within the transform
+         * function in cases where context linking is required.
+         *
+         * The context applied to the store should be accessible in any async code which
+         * continues from execution which began during the given function, however
+         * there are some situations in which `context loss` may occur.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const store = new AsyncLocalStorage();
+         *
+         * const channel = diagnostics_channel.channel('my-channel');
+         *
+         * channel.bindStore(store, (message) => {
+         *   const parent = store.getStore();
+         *   return new Span(message, parent);
+         * });
+         * channel.runStores({ some: 'message' }, () => {
+         *   store.getStore(); // Span({ some: 'message' })
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param context Message to send to subscribers and bind to stores
+         * @param fn Handler to run within the entered storage context
+         * @param thisArg The receiver to be used for the function call.
+         * @param args Optional arguments to pass to the function.
+         */
+        runStores(): void;
+    }
+    interface TracingChannelSubscribers<ContextType extends object> {
+        start: (message: ContextType) => void;
+        end: (
+            message: ContextType & {
+                error?: unknown;
+                result?: unknown;
+            },
+        ) => void;
+        asyncStart: (
+            message: ContextType & {
+                error?: unknown;
+                result?: unknown;
+            },
+        ) => void;
+        asyncEnd: (
+            message: ContextType & {
+                error?: unknown;
+                result?: unknown;
+            },
+        ) => void;
+        error: (
+            message: ContextType & {
+                error: unknown;
+            },
+        ) => void;
+    }
+    interface TracingChannelCollection<StoreType = unknown, ContextType = StoreType> {
+        start: Channel<StoreType, ContextType>;
+        end: Channel<StoreType, ContextType>;
+        asyncStart: Channel<StoreType, ContextType>;
+        asyncEnd: Channel<StoreType, ContextType>;
+        error: Channel<StoreType, ContextType>;
+    }
+    /**
+     * The class `TracingChannel` is a collection of `TracingChannel Channels` which
+     * together express a single traceable action. It is used to formalize and
+     * simplify the process of producing events for tracing application flow.{@link tracingChannel} is used to construct a`TracingChannel`. As with `Channel` it is recommended to create and reuse a
+     * single `TracingChannel` at the top-level of the file rather than creating them
+     * dynamically.
+     * @since v19.9.0
+     * @experimental
+     */
+    class TracingChannel<StoreType = unknown, ContextType extends object = {}> implements TracingChannelCollection {
+        start: Channel<StoreType, ContextType>;
+        end: Channel<StoreType, ContextType>;
+        asyncStart: Channel<StoreType, ContextType>;
+        asyncEnd: Channel<StoreType, ContextType>;
+        error: Channel<StoreType, ContextType>;
+        /**
+         * Helper to subscribe a collection of functions to the corresponding channels.
+         * This is the same as calling `channel.subscribe(onMessage)` on each channel
+         * individually.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.subscribe({
+         *   start(message) {
+         *     // Handle start message
+         *   },
+         *   end(message) {
+         *     // Handle end message
+         *   },
+         *   asyncStart(message) {
+         *     // Handle asyncStart message
+         *   },
+         *   asyncEnd(message) {
+         *     // Handle asyncEnd message
+         *   },
+         *   error(message) {
+         *     // Handle error message
+         *   },
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param subscribers Set of `TracingChannel Channels` subscribers
+         */
+        subscribe(subscribers: TracingChannelSubscribers<ContextType>): void;
+        /**
+         * Helper to unsubscribe a collection of functions from the corresponding channels.
+         * This is the same as calling `channel.unsubscribe(onMessage)` on each channel
+         * individually.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.unsubscribe({
+         *   start(message) {
+         *     // Handle start message
+         *   },
+         *   end(message) {
+         *     // Handle end message
+         *   },
+         *   asyncStart(message) {
+         *     // Handle asyncStart message
+         *   },
+         *   asyncEnd(message) {
+         *     // Handle asyncEnd message
+         *   },
+         *   error(message) {
+         *     // Handle error message
+         *   },
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param subscribers Set of `TracingChannel Channels` subscribers
+         * @return `true` if all handlers were successfully unsubscribed, and `false` otherwise.
+         */
+        unsubscribe(subscribers: TracingChannelSubscribers<ContextType>): void;
+        /**
+         * Trace a synchronous function call. This will always produce a `start event` and `end event` around the execution and may produce an `error event` if the given function throws an error.
+         * This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
+         * events should have any bound stores set to match this trace context.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.traceSync(() => {
+         *   // Do something
+         * }, {
+         *   some: 'thing',
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param fn Function to wrap a trace around
+         * @param context Shared object to correlate events through
+         * @param thisArg The receiver to be used for the function call
+         * @param args Optional arguments to pass to the function
+         * @return The return value of the given function
+         */
+        traceSync<ThisArg = any, Args extends any[] = any[]>(
+            fn: (this: ThisArg, ...args: Args) => any,
+            context?: ContextType,
+            thisArg?: ThisArg,
+            ...args: Args
+        ): void;
+        /**
+         * Trace a promise-returning function call. This will always produce a `start event` and `end event` around the synchronous portion of the
+         * function execution, and will produce an `asyncStart event` and `asyncEnd event` when a promise continuation is reached. It may also
+         * produce an `error event` if the given function throws an error or the
+         * returned promise rejects. This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
+         * events should have any bound stores set to match this trace context.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.tracePromise(async () => {
+         *   // Do something
+         * }, {
+         *   some: 'thing',
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param fn Promise-returning function to wrap a trace around
+         * @param context Shared object to correlate trace events through
+         * @param thisArg The receiver to be used for the function call
+         * @param args Optional arguments to pass to the function
+         * @return Chained from promise returned by the given function
+         */
+        tracePromise<ThisArg = any, Args extends any[] = any[]>(
+            fn: (this: ThisArg, ...args: Args) => Promise<any>,
+            context?: ContextType,
+            thisArg?: ThisArg,
+            ...args: Args
+        ): void;
+        /**
+         * Trace a callback-receiving function call. This will always produce a `start event` and `end event` around the synchronous portion of the
+         * function execution, and will produce a `asyncStart event` and `asyncEnd event` around the callback execution. It may also produce an `error event` if the given function throws an error or
+         * the returned
+         * promise rejects. This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
+         * events should have any bound stores set to match this trace context.
+         *
+         * The `position` will be -1 by default to indicate the final argument should
+         * be used as the callback.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.traceCallback((arg1, callback) => {
+         *   // Do something
+         *   callback(null, 'result');
+         * }, 1, {
+         *   some: 'thing',
+         * }, thisArg, arg1, callback);
+         * ```
+         *
+         * The callback will also be run with `channel.runStores(context, ...)` which
+         * enables context loss recovery in some cases.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         * const myStore = new AsyncLocalStorage();
+         *
+         * // The start channel sets the initial store data to something
+         * // and stores that store data value on the trace context object
+         * channels.start.bindStore(myStore, (data) => {
+         *   const span = new Span(data);
+         *   data.span = span;
+         *   return span;
+         * });
+         *
+         * // Then asyncStart can restore from that data it stored previously
+         * channels.asyncStart.bindStore(myStore, (data) => {
+         *   return data.span;
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param fn callback using function to wrap a trace around
+         * @param position Zero-indexed argument position of expected callback
+         * @param context Shared object to correlate trace events through
+         * @param thisArg The receiver to be used for the function call
+         * @param args Optional arguments to pass to the function
+         * @return The return value of the given function
+         */
+        traceCallback<Fn extends (this: any, ...args: any) => any>(
+            fn: Fn,
+            position: number | undefined,
+            context: ContextType | undefined,
+            thisArg: any,
+            ...args: Parameters<Fn>
+        ): void;
     }
 }
 declare module "node:diagnostics_channel" {

node/http.d.ts

@@ -9,12 +9,12 @@
  *
  * HTTP message headers are represented by an object like this:
  *
- * ```js
- * { 'content-length': '123',
- *   'content-type': 'text/plain',
- *   'connection': 'keep-alive',
- *   'host': 'example.com',
- *   'accept': '*' }
+ * ```json
+ * { "content-length": "123",
+ *   "content-type": "text/plain",
+ *   "connection": "keep-alive",
+ *   "host": "example.com",
+ *   "accept": "*" }
  * ```
  *
  * Keys are lowercased. Values are not modified.
@@ -1814,7 +1814,6 @@ declare module "http" {
      *
      * It is not necessary to use this method before passing headers to an HTTP request
      * or response. The HTTP module will automatically validate such headers.
-     * Examples:
      *
      * Example:
      *

node/module.d.ts

@@ -276,6 +276,20 @@ declare module "module" {
     }
     global {
         interface ImportMeta {
+            /**
+             * The directory name of the current module. This is the same as the `path.dirname()` of the `import.meta.filename`.
+             * **Caveat:** only present on `file:` modules.
+             */
+            dirname?: string;
+            /**
+             * The full absolute path and filename of the current module, with symlinks resolved.
+             * This is the same as the `url.fileURLToPath()` of the `import.meta.url`.
+             * **Caveat:** only local modules support this property. Modules not using the `file:` protocol will not provide it.
+             */
+            filename?: string;
+            /**
+             * The absolute `file:` URL of the module.
+             */
             url: string;
             /**
              * Provides a module-relative resolution function scoped to each module, returning

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "20.10.7",
+    "version": "20.11.0",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -224,7 +224,7 @@
     "dependencies": {
         "undici-types": "~5.26.4"
     },
-    "typesPublisherContentHash": "046bda929132f3b0ea734f317866954dfaa9a3eb325f8ac0f45460b1e007a9e2",
+    "typesPublisherContentHash": "ca77e7986f304692dfe04a1ec38a5dbebe32e569398b09ae4d01fd359a652186",
     "typeScriptVersion": "4.6",
     "nonNpm": true
 }

node/perf_hooks.d.ts

@@ -314,13 +314,15 @@ declare module "perf_hooks" {
          *    *     name: 'test',
          *    *     entryType: 'mark',
          *    *     startTime: 81.465639,
-         *    *     duration: 0
+         *    *     duration: 0,
+         *    *     detail: null
          *    *   },
          *    *   PerformanceEntry {
          *    *     name: 'meow',
          *    *     entryType: 'mark',
          *    *     startTime: 81.860064,
-         *    *     duration: 0
+         *    *     duration: 0,
+         *    *     detail: null
          *    *   }
          *    * ]
          *
@@ -355,7 +357,8 @@ declare module "perf_hooks" {
          *    *     name: 'meow',
          *    *     entryType: 'mark',
          *    *     startTime: 98.545991,
-         *    *     duration: 0
+         *    *     duration: 0,
+         *    *     detail: null
          *    *   }
          *    * ]
          *
@@ -368,7 +371,8 @@ declare module "perf_hooks" {
          *    *     name: 'test',
          *    *     entryType: 'mark',
          *    *     startTime: 63.518931,
-         *    *     duration: 0
+         *    *     duration: 0,
+         *    *     detail: null
          *    *   }
          *    * ]
          *
@@ -404,13 +408,15 @@ declare module "perf_hooks" {
          *    *     name: 'test',
          *    *     entryType: 'mark',
          *    *     startTime: 55.897834,
-         *    *     duration: 0
+         *    *     duration: 0,
+         *    *     detail: null
          *    *   },
          *    *   PerformanceEntry {
          *    *     name: 'meow',
          *    *     entryType: 'mark',
          *    *     startTime: 56.350146,
-         *    *     duration: 0
+         *    *     duration: 0,
+         *    *     detail: null
          *    *   }
          *    * ]
          *

node/process.d.ts

@@ -903,9 +903,14 @@ declare module "process" {
                  */
                 readonly sourceMapsEnabled: boolean;
                 /**
-                 * This function enables or disables the Source Map v3 support for stack traces.
-                 * It provides same features as launching Node.js process with commandline options --enable-source-maps.
-                 * @since v16.6.0
+                 * This function enables or disables the [Source Map v3](https://sourcemaps.info/spec.html) support for
+                 * stack traces.
+                 *
+                 * It provides same features as launching Node.js process with commandline options`--enable-source-maps`.
+                 *
+                 * Only source maps in JavaScript files that are loaded after source maps has been
+                 * enabled will be parsed and loaded.
+                 * @since v16.6.0, v14.18.0
                  * @experimental
                  */
                 setSourceMapsEnabled(value: boolean): void;

node/querystring.d.ts

@@ -74,10 +74,10 @@ declare module "querystring" {
      *
      * For example, the query string `'foo=bar&abc=xyz&abc=123'` is parsed into:
      *
-     * ```js
+     * ```json
      * {
-     *   foo: 'bar',
-     *   abc: ['xyz', '123']
+     *   "foo": "bar",
+     *   "abc": ["xyz", "123"]
      * }
      * ```
      *