@types/node 20.1.2 → 20.1.3

node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Wed, 10 May 2023 08:02:53 GMT
+ * Last updated: Thu, 11 May 2023 20:02:56 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`, `structuredClone`
 

node/assert.d.ts

@@ -15,10 +15,25 @@ declare module 'assert' {
          * Indicates the failure of an assertion. All errors thrown by the `node:assert`module will be instances of the `AssertionError` class.
          */
         class AssertionError extends Error {
+            /**
+             * Set to the `actual` argument for methods such as {@link assert.strictEqual()}.
+             */
             actual: unknown;
+            /**
+             * Set to the `expected` argument for methods such as {@link assert.strictEqual()}.
+             */
             expected: unknown;
+            /**
+             * Set to the passed in operator value.
+             */
             operator: string;
+            /**
+             * Indicates if the message was auto-generated (`true`) or not.
+             */
             generatedMessage: boolean;
+            /**
+             * Value is always `ERR_ASSERTION` to show that the error is an assertion error.
+             */
             code: 'ERR_ASSERTION';
             constructor(options?: {
                 /** If provided, the error message is set to this value. */

node/async_hooks.d.ts

@@ -274,19 +274,13 @@ declare module 'async_hooks' {
          * @param fn The function to bind to the current execution context.
          * @param type An optional name to associate with the underlying `AsyncResource`.
          */
-        static bind<Func extends (this: ThisArg, ...args: any[]) => any, ThisArg>(
-            fn: Func,
-            type?: string,
-            thisArg?: ThisArg
-        ): Func;
+        static bind<Func extends (this: ThisArg, ...args: any[]) => any, ThisArg>(fn: Func, type?: string, thisArg?: ThisArg): Func;
         /**
          * Binds the given function to execute to this `AsyncResource`'s scope.
          * @since v14.8.0, v12.19.0
          * @param fn The function to bind to the current `AsyncResource`.
          */
-        bind<Func extends (...args: any[]) => any>(
-            fn: Func
-        ): Func;
+        bind<Func extends (...args: any[]) => any>(fn: Func): Func;
         /**
          * Call the provided function with the provided arguments in the execution context
          * of the async resource. This will establish the context, trigger the AsyncHooks
@@ -372,9 +366,7 @@ declare module 'async_hooks' {
          * @param fn The function to bind to the current execution context.
          * @return A new function that calls `fn` within the captured execution context.
          */
-        static bind<Func extends (...args: any[]) => any>(
-            fn: Func
-        ): Func;
+        static bind<Func extends (...args: any[]) => any>(fn: Func): Func;
         /**
          * Captures the current execution context and returns a function that accepts a
          * function as an argument. Whenever the returned function is called, it

node/crypto.d.ts

@@ -96,7 +96,7 @@ declare module 'crypto' {
         verifySpkac(spkac: NodeJS.ArrayBufferView): boolean;
     }
     namespace constants {
-        // https://nodejs.org/dist/latest-v10.x/docs/api/crypto.html#crypto_crypto_constants
+        // https://nodejs.org/dist/latest-v20.x/docs/api/crypto.html#crypto-constants
         const OPENSSL_VERSION_NUMBER: number;
         /** Applies multiple bug workarounds within OpenSSL. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html for detail. */
         const SSL_OP_ALL: number;

node/dns/promises.d.ts

@@ -344,6 +344,49 @@ declare module 'dns/promises' {
      * @param order must be `'ipv4first'` or `'verbatim'`.
      */
     function setDefaultResultOrder(order: 'ipv4first' | 'verbatim'): void;
+    /**
+     * An independent resolver for DNS requests.
+     *
+     * Creating a new resolver uses the default server settings. Setting
+     * the servers used for a resolver using `resolver.setServers()` does not affect
+     * other resolvers:
+     *
+     * ```js
+     * const { Resolver } = require('node:dns').promises;
+     * const resolver = new Resolver();
+     * resolver.setServers(['4.4.4.4']);
+     *
+     * // This request will use the server at 4.4.4.4, independent of global settings.
+     * resolver.resolve4('example.org').then((addresses) => {
+     *   // ...
+     * });
+     *
+     * // Alternatively, the same code can be written using async-await style.
+     * (async function() {
+     *   const addresses = await resolver.resolve4('example.org');
+     * })();
+     * ```
+     *
+     * The following methods from the `dnsPromises` API are available:
+     *
+     * * `resolver.getServers()`
+     * * `resolver.resolve()`
+     * * `resolver.resolve4()`
+     * * `resolver.resolve6()`
+     * * `resolver.resolveAny()`
+     * * `resolver.resolveCaa()`
+     * * `resolver.resolveCname()`
+     * * `resolver.resolveMx()`
+     * * `resolver.resolveNaptr()`
+     * * `resolver.resolveNs()`
+     * * `resolver.resolvePtr()`
+     * * `resolver.resolveSoa()`
+     * * `resolver.resolveSrv()`
+     * * `resolver.resolveTxt()`
+     * * `resolver.reverse()`
+     * * `resolver.setServers()`
+     * @since v10.6.0
+     */
     class Resolver {
         constructor(options?: ResolverOptions);
         cancel(): void;
@@ -352,6 +395,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/dns.d.ts

@@ -633,6 +633,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/events.d.ts

@@ -310,21 +310,63 @@ declare module 'events' {
          */
         static setMaxListeners(n?: number, ...eventTargets: Array<_DOMEventTarget | NodeJS.EventEmitter>): void;
         /**
-         * This symbol shall be used to install a listener for only monitoring `'error'`
-         * events. Listeners installed using this symbol are called before the regular
-         * `'error'` listeners are called.
+         * This symbol shall be used to install a listener for only monitoring `'error'`events. Listeners installed using this symbol are called before the regular`'error'` listeners are called.
          *
-         * Installing a listener using this symbol does not change the behavior once an
-         * `'error'` event is emitted, therefore the process will still crash if no
+         * Installing a listener using this symbol does not change the behavior once an`'error'` event is emitted. Therefore, the process will still crash if no
          * regular `'error'` listener is installed.
+         * @since v13.6.0, v12.17.0
          */
         static readonly errorMonitor: unique symbol;
+        /**
+         * Value: `Symbol.for('nodejs.rejection')`
+         *
+         * See how to write a custom `rejection handler`.
+         * @since v13.4.0, v12.16.0
+         */
         static readonly captureRejectionSymbol: unique symbol;
         /**
-         * Sets or gets the default captureRejection value for all emitters.
+         * Value: [boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type)
+         *
+         * Change the default `captureRejections` option on all new `EventEmitter` objects.
+         * @since v13.4.0, v12.16.0
          */
-        // TODO: These should be described using static getter/setter pairs:
         static captureRejections: boolean;
+        /**
+         * By default, a maximum of `10` listeners can be registered for any single
+         * event. This limit can be changed for individual `EventEmitter` instances
+         * using the `emitter.setMaxListeners(n)` method. To change the default
+         * for _all_`EventEmitter` instances, the `events.defaultMaxListeners`property can be used. If this value is not a positive number, a `RangeError`is thrown.
+         *
+         * Take caution when setting the `events.defaultMaxListeners` because the
+         * change affects _all_`EventEmitter` instances, including those created before
+         * the change is made. However, calling `emitter.setMaxListeners(n)` still has
+         * precedence over `events.defaultMaxListeners`.
+         *
+         * This is not a hard limit. The `EventEmitter` instance will allow
+         * more listeners to be added but will output a trace warning to stderr indicating
+         * that a "possible EventEmitter memory leak" has been detected. For any single`EventEmitter`, the `emitter.getMaxListeners()` and `emitter.setMaxListeners()`methods can be used to
+         * temporarily avoid this warning:
+         *
+         * ```js
+         * import { EventEmitter } from 'node:events';
+         * const emitter = new EventEmitter();
+         * emitter.setMaxListeners(emitter.getMaxListeners() + 1);
+         * emitter.once('event', () => {
+         *   // do stuff
+         *   emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
+         * });
+         * ```
+         *
+         * The `--trace-warnings` command-line flag can be used to display the
+         * stack trace for such warnings.
+         *
+         * The emitted warning can be inspected with `process.on('warning')` and will
+         * have the additional `emitter`, `type`, and `count` properties, referring to
+         * the event emitter instance, the event's name and the number of attached
+         * listeners, respectively.
+         * Its `name` property is set to `'MaxListenersExceededWarning'`.
+         * @since v0.11.2
+         */
         static defaultMaxListeners: number;
     }
     import internal = require('node:events');

node/fs.d.ts

@@ -149,12 +149,38 @@ declare module 'fs' {
     }
     export interface StatsFs extends StatsFsBase<number> {}
     /**
-     * Provides information about a mounted file system
+     * Provides information about a mounted file system.
      *
-     * Objects returned from {@link statfs} and {@link statfsSync} are of this type.
-     * If `bigint` in the `options` passed to those methods is true, the numeric values
-     * will be `bigint` instead of `number`.
-     * @since  v18.15.0
+     * Objects returned from {@link statfs} and its synchronous counterpart are of
+     * this type. If `bigint` in the `options` passed to those methods is `true`, the
+     * numeric values will be `bigint` instead of `number`.
+     *
+     * ```console
+     * StatFs {
+     *   type: 1397114950,
+     *   bsize: 4096,
+     *   blocks: 121938943,
+     *   bfree: 61058895,
+     *   bavail: 61058895,
+     *   files: 999,
+     *   ffree: 1000000
+     * }
+     * ```
+     *
+     * `bigint` version:
+     *
+     * ```console
+     * StatFs {
+     *   type: 1397114950n,
+     *   bsize: 4096n,
+     *   blocks: 121938943n,
+     *   bfree: 61058895n,
+     *   bavail: 61058895n,
+     *   files: 999n,
+     *   ffree: 1000000n
+     * }
+     * ```
+     * @since v19.6.0, v18.15.0
      */
     export class StatsFs {}
     export interface BigIntStatsFs extends StatsFsBase<bigint> {}
@@ -214,6 +240,11 @@ declare module 'fs' {
          * @since v10.10.0
          */
         name: string;
+        /**
+         * The base path that this `fs.Dirent` object refers to.
+         * @since v20.1.0
+         */
+        path: string;
     }
     /**
      * A class representing a directory stream.

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "20.1.2",
+    "version": "20.1.3",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -232,6 +232,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "8dcc213ed756110c2b3b7a0f3a9b54ba17ba1eed24956abe206aa9f29dc5cd4d",
+    "typesPublisherContentHash": "a821357c6e565ca2470c2b7f613961727e971d28c26c1160834a50312f336893",
     "typeScriptVersion": "4.3"
 }

node/readline/promises.d.ts

@@ -1,22 +1,28 @@
 /**
- * The `readline/promise` module provides an API for reading lines of input from a Readable stream one line at a time.
- *
- * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/readline/promises.js)
  * @since v17.0.0
+ * @experimental
  */
 declare module 'readline/promises' {
     import { Interface as _Interface, ReadLineOptions, Completer, AsyncCompleter, Direction } from 'node:readline';
     import { Abortable } from 'node:events';
+    /**
+     * Instances of the `readlinePromises.Interface` class are constructed using the`readlinePromises.createInterface()` method. Every instance is associated with a
+     * single `input` `Readable` stream and a single `output` `Writable` stream.
+     * The `output` stream is used to print prompts for user input that arrives on,
+     * and is read from, the `input` stream.
+     * @since v17.0.0
+     */
     class Interface extends _Interface {
         /**
-         * The rl.question() method displays the query by writing it to the output, waits for user input to be provided on input,
-         * then invokes the callback function passing the provided input as the first argument.
+         * The `rl.question()` method displays the `query` by writing it to the `output`,
+         * waits for user input to be provided on `input`, then invokes the `callback`function passing the provided input as the first argument.
          *
-         * When called, rl.question() will resume the input stream if it has been paused.
+         * When called, `rl.question()` will resume the `input` stream if it has been
+         * paused.
          *
-         * If the readlinePromises.Interface was created with output set to null or undefined the query is not written.
+         * If the `Interface` was created with `output` set to `null` or`undefined` the `query` is not written.
          *
-         * If the question is called after rl.close(), it returns a rejected promise.
+         * If the question is called after `rl.close()`, it returns a rejected promise.
          *
          * Example usage:
          *
@@ -25,7 +31,7 @@ declare module 'readline/promises' {
          * console.log(`Oh, so your favorite food is ${answer}`);
          * ```
          *
-         * Using an AbortSignal to cancel a question.
+         * Using an `AbortSignal` to cancel a question.
          *
          * ```js
          * const signal = AbortSignal.timeout(10_000);
@@ -37,13 +43,16 @@ declare module 'readline/promises' {
          * const answer = await rl.question('What is your favorite food? ', { signal });
          * console.log(`Oh, so your favorite food is ${answer}`);
          * ```
-         *
          * @since v17.0.0
-         * @param query A statement or query to write to output, prepended to the prompt.
+         * @param query A statement or query to write to `output`, prepended to the prompt.
+         * @return A promise that is fulfilled with the user's input in response to the `query`.
          */
         question(query: string): Promise<string>;
         question(query: string, options: Abortable): Promise<string>;
     }
+    /**
+     * @since v17.0.0
+     */
     class Readline {
         /**
          * @param stream A TTY stream.
@@ -55,46 +64,66 @@ declare module 'readline/promises' {
             }
         );
         /**
-         * The `rl.clearLine()` method adds to the internal list of pending action an action that clears current line of the associated `stream` in a specified direction identified by `dir`.
-         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
+         * The `rl.clearLine()` method adds to the internal list of pending action an
+         * action that clears current line of the associated `stream` in a specified
+         * direction identified by `dir`.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
+         * @since v17.0.0
+         * @return this
          */
         clearLine(dir: Direction): this;
         /**
-         * The `rl.clearScreenDown()` method adds to the internal list of pending action an action that clears the associated `stream` from the current position of the cursor down.
-         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
+         * The `rl.clearScreenDown()` method adds to the internal list of pending action an
+         * action that clears the associated stream from the current position of the
+         * cursor down.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
+         * @since v17.0.0
+         * @return this
          */
         clearScreenDown(): this;
         /**
-         * The `rl.commit()` method sends all the pending actions to the associated `stream` and clears the internal list of pending actions.
+         * The `rl.commit()` method sends all the pending actions to the associated`stream` and clears the internal list of pending actions.
+         * @since v17.0.0
          */
         commit(): Promise<void>;
         /**
-         * The `rl.cursorTo()` method adds to the internal list of pending action an action that moves cursor to the specified position in the associated `stream`.
-         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
+         * The `rl.cursorTo()` method adds to the internal list of pending action an action
+         * that moves cursor to the specified position in the associated `stream`.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
+         * @since v17.0.0
+         * @return this
          */
         cursorTo(x: number, y?: number): this;
         /**
-         * The `rl.moveCursor()` method adds to the internal list of pending action an action that moves the cursor relative to its current position in the associated `stream`.
-         * Call `rl.commit()` to see the effect of this method, unless autoCommit: true was passed to the constructor.
+         * The `rl.moveCursor()` method adds to the internal list of pending action an
+         * action that moves the cursor _relative_ to its current position in the
+         * associated `stream`.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
+         * @since v17.0.0
+         * @return this
          */
         moveCursor(dx: number, dy: number): this;
         /**
-         * The `rl.rollback()` method clears the internal list of pending actions without sending it to the associated `stream`.
+         * The `rl.rollback` methods clears the internal list of pending actions without
+         * sending it to the associated `stream`.
+         * @since v17.0.0
+         * @return this
          */
         rollback(): this;
     }
     /**
-     * The `readlinePromises.createInterface()` method creates a new `readlinePromises.Interface` instance.
+     * The `readlinePromises.createInterface()` method creates a new `readlinePromises.Interface`instance.
      *
      * ```js
      * const readlinePromises = require('node:readline/promises');
      * const rl = readlinePromises.createInterface({
      *   input: process.stdin,
-     *   output: process.stdout
+     *   output: process.stdout,
      * });
      * ```
      *
-     * Once the `readlinePromises.Interface` instance is created, the most common case is to listen for the `'line'` event:
+     * Once the `readlinePromises.Interface` instance is created, the most common case
+     * is to listen for the `'line'` event:
      *
      * ```js
      * rl.on('line', (line) => {
@@ -102,42 +131,13 @@ declare module 'readline/promises' {
      * });
      * ```
      *
-     * If `terminal` is `true` for this instance then the `output` stream will get the best compatibility if it defines an `output.columns` property,
-     * and emits a `'resize'` event on the `output`, if or when the columns ever change (`process.stdout` does this automatically when it is a TTY).
-     *
-     * ## Use of the `completer` function
-     *
-     * The `completer` function takes the current line entered by the user as an argument, and returns an `Array` with 2 entries:
-     *
-     * - An Array with matching entries for the completion.
-     * - The substring that was used for the matching.
-     *
-     * For instance: `[[substr1, substr2, ...], originalsubstring]`.
-     *
-     * ```js
-     * function completer(line) {
-     *   const completions = '.help .error .exit .quit .q'.split(' ');
-     *   const hits = completions.filter((c) => c.startsWith(line));
-     *   // Show all completions if none found
-     *   return [hits.length ? hits : completions, line];
-     * }
-     * ```
-     *
-     * The `completer` function can also returns a `Promise`, or be asynchronous:
-     *
-     * ```js
-     * async function completer(linePartial) {
-     *   await someAsyncWork();
-     *   return [['123'], linePartial];
-     * }
-     * ```
+     * If `terminal` is `true` for this instance then the `output` stream will get
+     * the best compatibility if it defines an `output.columns` property and emits
+     * a `'resize'` event on the `output` if or when the columns ever change
+     * (`process.stdout` does this automatically when it is a TTY).
+     * @since v17.0.0
      */
-    function createInterface(
-        input: NodeJS.ReadableStream,
-        output?: NodeJS.WritableStream,
-        completer?: Completer | AsyncCompleter,
-        terminal?: boolean,
-    ): Interface;
+    function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
     function createInterface(options: ReadLineOptions): Interface;
 }
 declare module 'node:readline/promises' {