@types/node 18.11.5 → 20.2.5

node/https.d.ts

@@ -1,7 +1,7 @@
 /**
  * HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
  * separate module.
- * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/https.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/https.js)
  */
 declare module 'https' {
     import { Duplex } from 'node:stream';
@@ -14,6 +14,7 @@ declare module 'https' {
     > = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions<Request, Response>;
     type RequestOptions = http.RequestOptions &
         tls.SecureContextOptions & {
+            checkServerIdentity?: typeof tls.checkServerIdentity | undefined;
             rejectUnauthorized?: boolean | undefined; // Defaults to true
             servername?: string | undefined; // SNI TLS Extension
         };
@@ -58,22 +59,9 @@ declare module 'https' {
         closeIdleConnections(): void;
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        addListener(
-            event: 'newSession',
-            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
-        ): this;
-        addListener(
-            event: 'OCSPRequest',
-            listener: (
-                certificate: Buffer,
-                issuer: Buffer,
-                callback: (err: Error | null, resp: Buffer) => void,
-            ) => void,
-        ): this;
-        addListener(
-            event: 'resumeSession',
-            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
-        ): this;
+        addListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        addListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        addListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
         addListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         addListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         addListener(event: 'close', listener: () => void): this;
@@ -83,29 +71,13 @@ declare module 'https' {
         addListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
         addListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         addListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        addListener(
-            event: 'connect',
-            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
-        ): this;
+        addListener(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         addListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
-        addListener(
-            event: 'upgrade',
-            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
-        ): this;
+        addListener(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         emit(event: string, ...args: any[]): boolean;
         emit(event: 'keylog', line: Buffer, tlsSocket: tls.TLSSocket): boolean;
-        emit(
-            event: 'newSession',
-            sessionId: Buffer,
-            sessionData: Buffer,
-            callback: (err: Error, resp: Buffer) => void,
-        ): boolean;
-        emit(
-            event: 'OCSPRequest',
-            certificate: Buffer,
-            issuer: Buffer,
-            callback: (err: Error | null, resp: Buffer) => void,
-        ): boolean;
+        emit(event: 'newSession', sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void): boolean;
+        emit(event: 'OCSPRequest', certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void): boolean;
         emit(event: 'resumeSession', sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void): boolean;
         emit(event: 'secureConnection', tlsSocket: tls.TLSSocket): boolean;
         emit(event: 'tlsClientError', err: Error, tlsSocket: tls.TLSSocket): boolean;
@@ -116,39 +88,32 @@ declare module 'https' {
         emit(
             event: 'checkContinue',
             req: InstanceType<Request>,
-            res: InstanceType<Response> & { req: InstanceType<Request> },
+            res: InstanceType<Response> & {
+                req: InstanceType<Request>;
+            }
         ): boolean;
         emit(
             event: 'checkExpectation',
             req: InstanceType<Request>,
-            res: InstanceType<Response> & { req: InstanceType<Request> },
+            res: InstanceType<Response> & {
+                req: InstanceType<Request>;
+            }
         ): boolean;
         emit(event: 'clientError', err: Error, socket: Duplex): boolean;
         emit(event: 'connect', req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
         emit(
             event: 'request',
             req: InstanceType<Request>,
-            res: InstanceType<Response> & { req: InstanceType<Request> },
+            res: InstanceType<Response> & {
+                req: InstanceType<Request>;
+            }
         ): boolean;
         emit(event: 'upgrade', req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        on(
-            event: 'newSession',
-            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
-        ): this;
-        on(
-            event: 'OCSPRequest',
-            listener: (
-                certificate: Buffer,
-                issuer: Buffer,
-                callback: (err: Error | null, resp: Buffer) => void,
-            ) => void,
-        ): this;
-        on(
-            event: 'resumeSession',
-            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
-        ): this;
+        on(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        on(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        on(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
         on(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         on(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         on(event: 'close', listener: () => void): this;
@@ -163,22 +128,9 @@ declare module 'https' {
         on(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        once(
-            event: 'newSession',
-            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
-        ): this;
-        once(
-            event: 'OCSPRequest',
-            listener: (
-                certificate: Buffer,
-                issuer: Buffer,
-                callback: (err: Error | null, resp: Buffer) => void,
-            ) => void,
-        ): this;
-        once(
-            event: 'resumeSession',
-            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
-        ): this;
+        once(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        once(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        once(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
         once(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         once(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         once(event: 'close', listener: () => void): this;
@@ -193,22 +145,9 @@ declare module 'https' {
         once(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        prependListener(
-            event: 'newSession',
-            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
-        ): this;
-        prependListener(
-            event: 'OCSPRequest',
-            listener: (
-                certificate: Buffer,
-                issuer: Buffer,
-                callback: (err: Error | null, resp: Buffer) => void,
-            ) => void,
-        ): this;
-        prependListener(
-            event: 'resumeSession',
-            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
-        ): this;
+        prependListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        prependListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        prependListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
         prependListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         prependListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         prependListener(event: 'close', listener: () => void): this;
@@ -218,33 +157,14 @@ declare module 'https' {
         prependListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
         prependListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         prependListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        prependListener(
-            event: 'connect',
-            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
-        ): this;
+        prependListener(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         prependListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
-        prependListener(
-            event: 'upgrade',
-            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
-        ): this;
+        prependListener(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        prependOnceListener(
-            event: 'newSession',
-            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
-        ): this;
-        prependOnceListener(
-            event: 'OCSPRequest',
-            listener: (
-                certificate: Buffer,
-                issuer: Buffer,
-                callback: (err: Error | null, resp: Buffer) => void,
-            ) => void,
-        ): this;
-        prependOnceListener(
-            event: 'resumeSession',
-            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
-        ): this;
+        prependOnceListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
+        prependOnceListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
+        prependOnceListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
         prependOnceListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         prependOnceListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         prependOnceListener(event: 'close', listener: () => void): this;
@@ -254,25 +174,19 @@ declare module 'https' {
         prependOnceListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
         prependOnceListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         prependOnceListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        prependOnceListener(
-            event: 'connect',
-            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
-        ): this;
+        prependOnceListener(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         prependOnceListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
-        prependOnceListener(
-            event: 'upgrade',
-            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
-        ): this;
+        prependOnceListener(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
     }
     /**
      * ```js
      * // curl -k https://localhost:8000/
-     * const https = require('https');
-     * const fs = require('fs');
+     * const https = require('node:https');
+     * const fs = require('node:fs');
      *
      * const options = {
      *   key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
-     *   cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
+     *   cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),
      * };
      *
      * https.createServer(options, (req, res) => {
@@ -284,12 +198,12 @@ declare module 'https' {
      * Or
      *
      * ```js
-     * const https = require('https');
-     * const fs = require('fs');
+     * const https = require('node:https');
+     * const fs = require('node:fs');
      *
      * const options = {
      *   pfx: fs.readFileSync('test/fixtures/test_cert.pfx'),
-     *   passphrase: 'sample'
+     *   passphrase: 'sample',
      * };
      *
      * https.createServer(options, (req, res) => {
@@ -325,13 +239,13 @@ declare module 'https' {
      * upload a file with a POST request, then write to the `ClientRequest` object.
      *
      * ```js
-     * const https = require('https');
+     * const https = require('node:https');
      *
      * const options = {
      *   hostname: 'encrypted.google.com',
      *   port: 443,
      *   path: '/',
-     *   method: 'GET'
+     *   method: 'GET',
      * };
      *
      * const req = https.request(options, (res) => {
@@ -358,7 +272,7 @@ declare module 'https' {
      *   path: '/',
      *   method: 'GET',
      *   key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
-     *   cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
+     *   cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),
      * };
      * options.agent = new https.Agent(options);
      *
@@ -377,7 +291,7 @@ declare module 'https' {
      *   method: 'GET',
      *   key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
      *   cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),
-     *   agent: false
+     *   agent: false,
      * };
      *
      * const req = https.request(options, (res) => {
@@ -398,9 +312,9 @@ declare module 'https' {
      * Example pinning on certificate fingerprint, or the public key (similar to`pin-sha256`):
      *
      * ```js
-     * const tls = require('tls');
-     * const https = require('https');
-     * const crypto = require('crypto');
+     * const tls = require('node:tls');
+     * const https = require('node:https');
+     * const crypto = require('node:crypto');
      *
      * function sha256(s) {
      *   return crypto.createHash('sha256').update(s).digest('base64');
@@ -417,7 +331,7 @@ declare module 'https' {
      *       return err;
      *     }
      *
-     *     // Pin the public key, similar to HPKP pin-sha25 pinning
+     *     // Pin the public key, similar to HPKP pin-sha256 pinning
      *     const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=';
      *     if (sha256(cert.pubkey) !== pubkey256) {
      *       const msg = 'Certificate verification error: ' +
@@ -492,15 +406,8 @@ declare module 'https' {
      * @since v0.3.6
      * @param options Accepts all `options` from `request`, with some differences in default values:
      */
-    function request(
-        options: RequestOptions | string | URL,
-        callback?: (res: http.IncomingMessage) => void,
-    ): http.ClientRequest;
-    function request(
-        url: string | URL,
-        options: RequestOptions,
-        callback?: (res: http.IncomingMessage) => void,
-    ): http.ClientRequest;
+    function request(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function request(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
     /**
      * Like `http.get()` but for HTTPS.
      *
@@ -508,7 +415,7 @@ declare module 'https' {
      * string, it is automatically parsed with `new URL()`. If it is a `URL` object, it will be automatically converted to an ordinary `options` object.
      *
      * ```js
-     * const https = require('https');
+     * const https = require('node:https');
      *
      * https.get('https://encrypted.google.com/', (res) => {
      *   console.log('statusCode:', res.statusCode);
@@ -525,15 +432,8 @@ declare module 'https' {
      * @since v0.3.6
      * @param options Accepts the same `options` as {@link request}, with the `method` always set to `GET`.
      */
-    function get(
-        options: RequestOptions | string | URL,
-        callback?: (res: http.IncomingMessage) => void,
-    ): http.ClientRequest;
-    function get(
-        url: string | URL,
-        options: RequestOptions,
-        callback?: (res: http.IncomingMessage) => void,
-    ): http.ClientRequest;
+    function get(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function get(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
     let globalAgent: Agent;
 }
 declare module 'node:https' {

node/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for non-npm package Node.js 18.11
+// Type definitions for non-npm package Node.js 20.2
 // Project: https://nodejs.org/
 // Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
 //                 DefinitelyTyped <https://github.com/DefinitelyTyped>
@@ -41,6 +41,7 @@
 //                 Linus Unnebäck <https://github.com/LinusU>
 //                 wafuwafu13 <https://github.com/wafuwafu13>
 //                 Matteo Collina <https://github.com/mcollina>
+//                 Dmitry Semigradsky <https://github.com/Semigradsky>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /**

node/inspector.d.ts

@@ -8,14 +8,21 @@
 // tslint:disable:max-line-length
 
 /**
- * The `inspector` module provides an API for interacting with the V8 inspector.
+ * The `node:inspector` module provides an API for interacting with the V8
+ * inspector.
  *
  * It can be accessed using:
  *
  * ```js
- * const inspector = require('inspector');
+ * import * as inspector from 'node:inspector/promises';
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/inspector.js)
+ *
+ * or
+ *
+ * ```js
+ * import * as inspector from 'node:inspector';
+ * ```
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/inspector.js)
  */
 declare module 'inspector' {
     import EventEmitter = require('node:events');

node/module.d.ts

@@ -10,9 +10,9 @@ declare module 'module' {
          * does not add or remove exported names from the `ES Modules`.
          *
          * ```js
-         * const fs = require('fs');
-         * const assert = require('assert');
-         * const { syncBuiltinESMExports } = require('module');
+         * const fs = require('node:fs');
+         * const assert = require('node:assert');
+         * const { syncBuiltinESMExports } = require('node:module');
          *
          * fs.readFile = newAPI;
          *
@@ -26,7 +26,7 @@ declare module 'module' {
          *
          * syncBuiltinESMExports();
          *
-         * import('fs').then((esmFS) => {
+         * import('node:fs').then((esmFS) => {
          *   // It syncs the existing readFile property with the new value
          *   assert.strictEqual(esmFS.readFile, newAPI);
          *   // readFileSync has been deleted from the required fs
@@ -44,6 +44,7 @@ declare module 'module' {
          * `path` is the resolved path for the file for which a corresponding source map
          * should be fetched.
          * @since v13.7.0, v12.17.0
+         * @return Returns `module.SourceMap` if a source map is found, `undefined` otherwise.
          */
         function findSourceMap(path: string, error?: Error): SourceMap;
         interface SourceMapPayload {
@@ -85,6 +86,7 @@ declare module 'module' {
         static wrap(code: string): string;
         static createRequire(path: string | URL): NodeRequire;
         static builtinModules: string[];
+        static isBuiltin(moduleName: string): boolean;
         static Module: typeof Module;
         constructor(id: string, parent?: Module);
     }

node/net.d.ts

@@ -1,16 +1,16 @@
 /**
  * > Stability: 2 - Stable
  *
- * The `net` module provides an asynchronous network API for creating stream-based
+ * The `node:net` module provides an asynchronous network API for creating stream-based
  * TCP or `IPC` servers ({@link createServer}) and clients
  * ({@link createConnection}).
  *
  * It can be accessed using:
  *
  * ```js
- * const net = require('net');
+ * const net = require('node:net');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/net.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/net.js)
  */
 declare module 'net' {
     import * as stream from 'node:stream';
@@ -57,6 +57,14 @@ declare module 'net' {
         noDelay?: boolean | undefined;
         keepAlive?: boolean | undefined;
         keepAliveInitialDelay?: number | undefined;
+        /**
+         * @since v18.13.0
+         */
+        autoSelectFamily?: boolean | undefined;
+        /**
+         * @since v18.13.0
+         */
+        autoSelectFamilyAttemptTimeout?: number | undefined;
     }
     interface IpcSocketConnectOpts extends ConnectOpts {
         path: string;
@@ -133,13 +141,10 @@ declare module 'net' {
         pause(): this;
         /**
          * Close the TCP connection by sending an RST packet and destroy the stream.
-         * If this TCP socket is in connecting status, it will send an RST packet
-         * and destroy this TCP socket once it is connected. Otherwise, it will call
-         * `socket.destroy` with an `ERR_SOCKET_CLOSED` Error. If this is not a TCP socket
-         * (for example, a pipe), calling this method will immediately throw
-         * an `ERR_INVALID_HANDLE_TYPE` Error.
-         * @since v18.3.0
-         * @return The socket itself.
+         * If this TCP socket is in connecting status, it will send an RST packet and destroy this TCP socket once it is connected.
+         * Otherwise, it will call `socket.destroy` with an `ERR_SOCKET_CLOSED` Error.
+         * If this is not a TCP socket (for example, a pipe), calling this method will immediately throw an `ERR_INVALID_HANDLE_TYPE` Error.
+         * @since v18.3.0, v16.17.0
          */
         resetAndDestroy(): this;
         /**
@@ -261,6 +266,12 @@ declare module 'net' {
          * @since v6.1.0
          */
         readonly connecting: boolean;
+        /**
+         * This is `true` if the socket is not connected yet, either because `.connect()`has not yet been called or because it is still in the process of connecting
+         * (see `socket.connecting`).
+         * @since v11.2.0, v10.16.0
+         */
+        readonly pending: boolean;
         /**
          * See `writable.destroyed` for further details.
          */
@@ -279,12 +290,16 @@ declare module 'net' {
         readonly localPort?: number;
         /**
          * The string representation of the local IP family. `'IPv4'` or `'IPv6'`.
-         * @since v18.8.0
+         * @since v18.8.0, v16.18.0
          */
         readonly localFamily?: string;
         /**
          * This property represents the state of the connection as a string.
-         * @see {https://nodejs.org/api/net.html#socketreadystate}
+         *
+         * * If the stream is connecting `socket.readyState` is `opening`.
+         * * If the stream is readable and writable, it is `open`.
+         * * If the stream is readable and not writable, it is `readOnly`.
+         * * If the stream is not readable and writable, it is `writeOnly`.
          * @since v0.5.0
          */
         readonly readyState: SocketReadyState;
@@ -305,7 +320,8 @@ declare module 'net' {
          */
         readonly remotePort?: number | undefined;
         /**
-         * The socket timeout in milliseconds as set by socket.setTimeout(). It is undefined if a timeout has not been set.
+         * The socket timeout in milliseconds as set by `socket.setTimeout()`.
+         * It is `undefined` if a timeout has not been set.
          * @since v10.7.0
          */
         readonly timeout?: number | undefined;
@@ -486,7 +502,7 @@ declare module 'net' {
          * ```js
          * server.on('error', (e) => {
          *   if (e.code === 'EADDRINUSE') {
-         *     console.log('Address in use, retrying...');
+         *     console.error('Address in use, retrying...');
          *     setTimeout(() => {
          *       server.close();
          *       server.listen(PORT, HOST);
@@ -708,7 +724,7 @@ declare module 'net' {
      * on port 8124:
      *
      * ```js
-     * const net = require('net');
+     * const net = require('node:net');
      * const server = net.createServer((c) => {
      *   // 'connection' listener.
      *   console.log('client connected');
@@ -846,6 +862,7 @@ declare module 'net' {
     class SocketAddress {
         constructor(options: SocketAddressInitOptions);
         /**
+         * Either \`'ipv4'\` or \`'ipv6'\`.
          * @since v15.14.0, v14.18.0
          */
         readonly address: string;

node/os.d.ts

@@ -1,11 +1,11 @@
 /**
- * The `os` module provides operating system-related utility methods and
+ * The `node:os` module provides operating system-related utility methods and
  * properties. It can be accessed using:
  *
  * ```js
- * const os = require('os');
+ * const os = require('node:os');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/os.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/os.js)
  */
 declare module 'os' {
     interface CpuInfo {
@@ -75,6 +75,7 @@ declare module 'os' {
     function totalmem(): number;
     /**
      * Returns an array of objects containing information about each logical CPU core.
+     * The array will be empty if no CPU information is available, such as if the`/proc` file system is unavailable.
      *
      * The properties included on each object include:
      *
@@ -88,8 +89,8 @@ declare module 'os' {
      *       nice: 0,
      *       sys: 30340,
      *       idle: 1070356870,
-     *       irq: 0
-     *     }
+     *       irq: 0,
+     *     },
      *   },
      *   {
      *     model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',
@@ -99,8 +100,8 @@ declare module 'os' {
      *       nice: 0,
      *       sys: 26980,
      *       idle: 1071569080,
-     *       irq: 0
-     *     }
+     *       irq: 0,
+     *     },
      *   },
      *   {
      *     model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',
@@ -110,8 +111,8 @@ declare module 'os' {
      *       nice: 0,
      *       sys: 21750,
      *       idle: 1070919370,
-     *       irq: 0
-     *     }
+     *       irq: 0,
+     *     },
      *   },
      *   {
      *     model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',
@@ -121,17 +122,28 @@ declare module 'os' {
      *       nice: 0,
      *       sys: 19430,
      *       idle: 1070905480,
-     *       irq: 20
-     *     }
+     *       irq: 20,
+     *     },
      *   },
      * ]
      * ```
      *
      * `nice` values are POSIX-only. On Windows, the `nice` values of all processors
      * are always 0.
+     *
+     * `os.cpus().length` should not be used to calculate the amount of parallelism
+     * available to an application. Use {@link availableParallelism} for this purpose.
      * @since v0.3.3
      */
     function cpus(): CpuInfo[];
+    /**
+     * Returns an estimate of the default amount of parallelism a program should use.
+     * Always returns a value greater than zero.
+     *
+     * This function is a small wrapper about libuv's [`uv_available_parallelism()`](https://docs.libuv.org/en/v1.x/misc.html#c.uv_available_parallelism).
+     * @since v19.4.0, v18.14.0
+     */
+    function availableParallelism(): number;
     /**
      * Returns the operating system name as returned by [`uname(3)`](https://linux.die.net/man/3/uname). For example, it
      * returns `'Linux'` on Linux, `'Darwin'` on macOS, and `'Windows_NT'` on Windows.
@@ -415,12 +427,11 @@ declare module 'os' {
      */
     function platform(): NodeJS.Platform;
     /**
-     * Returns the machine type as a string, such as arm, aarch64, mips, mips64, ppc64, ppc64le, s390, s390x, i386, i686, x86_64.
+     * Returns the machine type as a string, such as `arm`, `arm64`, `aarch64`,`mips`, `mips64`, `ppc64`, `ppc64le`, `s390`, `s390x`, `i386`, `i686`, `x86_64`.
      *
-     * On POSIX systems, the machine type is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname).
-     * On Windows, `RtlGetVersion()` is used, and if it is not available, `GetVersionExW()` will be used.
-     * See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information.
-     * @since v18.9.0
+     * On POSIX systems, the machine type is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname). On Windows, `RtlGetVersion()` is used, and if it is not
+     * available, `GetVersionExW()` will be used. See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information.
+     * @since v18.9.0, v16.18.0
      */
     function machine(): string;
     /**