@types/node 20.19.1 → 20.19.3

node v20.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/v20.
 
 ### Additional Details
- * Last updated: Mon, 16 Jun 2025 11:02:21 GMT
+ * Last updated: Tue, 01 Jul 2025 19:02:07 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

node v20.19/http.d.ts

@@ -44,7 +44,7 @@ declare module "http" {
     import { URL } from "node:url";
     import { LookupOptions } from "node:dns";
     import { EventEmitter } from "node:events";
-    import { LookupFunction, Server as NetServer, Socket, TcpSocketConnectOpts } from "node:net";
+    import { LookupFunction, NetConnectOpts, Server as NetServer, Socket, TcpSocketConnectOpts } from "node:net";
     // incoming headers will never contain number
     interface IncomingHttpHeaders extends NodeJS.Dict<string | string[]> {
         accept?: string | undefined;
@@ -1449,6 +1449,21 @@ declare module "http" {
          */
         scheduling?: "fifo" | "lifo" | undefined;
     }
+    interface AgentGetNameOptions {
+        /**
+         * A domain name or IP address of the server to issue the request to
+         */
+        host?: string | undefined;
+        /**
+         * Port of remote server
+         */
+        port?: number | undefined;
+        /**
+         * Local interface to bind for network connections when issuing the request
+         */
+        localAddress?: string | undefined;
+        family?: 4 | 6 | undefined;
+    }
     /**
      * An `Agent` is responsible for managing connection persistence
      * and reuse for HTTP clients. It maintains a queue of pending requests
@@ -1568,6 +1583,68 @@ declare module "http" {
          * @since v0.11.4
          */
         destroy(): void;
+        /**
+         * Produces a socket/stream to be used for HTTP requests.
+         *
+         * By default, this function is the same as `net.createConnection()`. However,
+         * custom agents may override this method in case greater flexibility is desired.
+         *
+         * A socket/stream can be supplied in one of two ways: by returning the
+         * socket/stream from this function, or by passing the socket/stream to `callback`.
+         *
+         * This method is guaranteed to return an instance of the `net.Socket` class,
+         * a subclass of `stream.Duplex`, unless the user specifies a socket
+         * type other than `net.Socket`.
+         *
+         * `callback` has a signature of `(err, stream)`.
+         * @since v0.11.4
+         * @param options Options containing connection details. Check `createConnection` for the format of the options
+         * @param callback Callback function that receives the created socket
+         */
+        createConnection(
+            options: NetConnectOpts,
+            callback?: (err: Error | null, stream: stream.Duplex) => void,
+        ): stream.Duplex;
+        /**
+         * Called when `socket` is detached from a request and could be persisted by the`Agent`. Default behavior is to:
+         *
+         * ```js
+         * socket.setKeepAlive(true, this.keepAliveMsecs);
+         * socket.unref();
+         * return true;
+         * ```
+         *
+         * This method can be overridden by a particular `Agent` subclass. If this
+         * method returns a falsy value, the socket will be destroyed instead of persisting
+         * it for use with the next request.
+         *
+         * The `socket` argument can be an instance of `net.Socket`, a subclass of `stream.Duplex`.
+         * @since v8.1.0
+         */
+        keepSocketAlive(socket: stream.Duplex): void;
+        /**
+         * Called when `socket` is attached to `request` after being persisted because of
+         * the keep-alive options. Default behavior is to:
+         *
+         * ```js
+         * socket.ref();
+         * ```
+         *
+         * This method can be overridden by a particular `Agent` subclass.
+         *
+         * The `socket` argument can be an instance of `net.Socket`, a subclass of `stream.Duplex`.
+         * @since v8.1.0
+         */
+        reuseSocket(socket: stream.Duplex, request: ClientRequest): void;
+        /**
+         * Get a unique name for a set of request options, to determine whether a
+         * connection can be reused. For an HTTP agent, this returns`host:port:localAddress` or `host:port:localAddress:family`. For an HTTPS agent,
+         * the name includes the CA, cert, ciphers, and other HTTPS/TLS-specific options
+         * that determine socket reusability.
+         * @since v0.11.4
+         * @param options A set of options providing information for name generation
+         */
+        getName(options?: AgentGetNameOptions): string;
     }
     const METHODS: string[];
     const STATUS_CODES: {

node v20.19/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "20.19.1",
+    "version": "20.19.3",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -215,6 +215,6 @@
         "undici-types": "~6.21.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "cc9b44df0c3d7290cabaa4b43a7a43cb4eda0119a979750949d8687b20ded030",
+    "typesPublisherContentHash": "d0d6de51333cb0875f3f866ab97c3894e52a50e2807a95573312ab72c1e1053e",
     "typeScriptVersion": "5.1"
 }