@types/node 16.18.77 → 16.18.79

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: Tue, 30 Jan 2024 21:35:45 GMT
+ * Last updated: Thu, 01 Feb 2024 17:35:23 GMT
  * Dependencies: none
 
 # Credits

node v16.18/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "16.18.77",
+    "version": "16.18.79",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -222,6 +222,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "55fb556c3e611faca0d4269a09dd87ad00280e698cc3f38ac8b1e61f75030feb",
+    "typesPublisherContentHash": "052d62dae6ffb01bc2ee31005dcedbade3b7287f6e0ea97a6302c5d2fd41aec9",
     "typeScriptVersion": "4.6"
 }

node v16.18/tls.d.ts

@@ -11,6 +11,7 @@
 declare module "tls" {
     import { X509Certificate } from "node:crypto";
     import * as net from "node:net";
+    import * as stream from "stream";
     const CLIENT_RENEG_LIMIT: number;
     const CLIENT_RENEG_WINDOW: number;
     interface Certificate {
@@ -140,7 +141,7 @@ declare module "tls" {
         /**
          * Construct a new tls.TLSSocket object from an existing TCP socket.
          */
-        constructor(socket: net.Socket, options?: TLSSocketOptions);
+        constructor(socket: net.Socket | stream.Duplex, options?: TLSSocketOptions);
         /**
          * Returns `true` if the peer certificate was signed by one of the CAs specified
          * when creating the `tls.TLSSocket` instance, otherwise `false`.

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/tls.d.ts

@@ -11,6 +11,7 @@
 declare module "tls" {
     import { X509Certificate } from "node:crypto";
     import * as net from "node:net";
+    import * as stream from "stream";
     const CLIENT_RENEG_LIMIT: number;
     const CLIENT_RENEG_WINDOW: number;
     interface Certificate {
@@ -140,7 +141,7 @@ declare module "tls" {
         /**
          * Construct a new tls.TLSSocket object from an existing TCP socket.
          */
-        constructor(socket: net.Socket, options?: TLSSocketOptions);
+        constructor(socket: net.Socket | stream.Duplex, options?: TLSSocketOptions);
         /**
          * Returns `true` if the peer certificate was signed by one of the CAs specified
          * when creating the `tls.TLSSocket` instance, otherwise `false`.