@types/node 22.8.6 → 22.9.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: Thu, 31 Oct 2024 18:02:52 GMT
+ * Last updated: Tue, 05 Nov 2024 01:29:26 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "22.8.6",
+    "version": "22.9.0",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -220,6 +220,6 @@
         "undici-types": "~6.19.8"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "b5e95f7873a1811a61b3409c809ee30655d0268d76d767dbe9efc27cb421459f",
+    "typesPublisherContentHash": "9fd729e1c7f77c7e5ce00a1690558c1aa810d60c39e52aefa248f3c6c5fb5e7a",
     "typeScriptVersion": "4.8"
 }

node/readline/promises.d.ts

@@ -3,8 +3,13 @@
  * @experimental
  */
 declare module "readline/promises" {
-    import { AsyncCompleter, Completer, Direction, Interface as _Interface, ReadLineOptions } from "node:readline";
     import { Abortable } from "node:events";
+    import {
+        CompleterResult,
+        Direction,
+        Interface as _Interface,
+        ReadLineOptions as _ReadLineOptions,
+    } from "node:readline";
     /**
      * 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.
@@ -111,6 +116,13 @@ declare module "readline/promises" {
          */
         rollback(): this;
     }
+    type Completer = (line: string) => CompleterResult | Promise<CompleterResult>;
+    interface ReadLineOptions extends Omit<_ReadLineOptions, "completer"> {
+        /**
+         * An optional function used for Tab autocompletion.
+         */
+        completer?: Completer | undefined;
+    }
     /**
      * The `readlinePromises.createInterface()` method creates a new `readlinePromises.Interface` instance.
      *
@@ -140,7 +152,7 @@ declare module "readline/promises" {
     function createInterface(
         input: NodeJS.ReadableStream,
         output?: NodeJS.WritableStream,
-        completer?: Completer | AsyncCompleter,
+        completer?: Completer,
         terminal?: boolean,
     ): Interface;
     function createInterface(options: ReadLineOptions): Interface;

node/readline.d.ts

@@ -314,29 +314,78 @@ declare module "readline" {
     ) => void;
     export type CompleterResult = [string[], string];
     export interface ReadLineOptions {
+        /**
+         * The [`Readable`](https://nodejs.org/docs/latest-v22.x/api/stream.html#readable-streams) stream to listen to
+         */
         input: NodeJS.ReadableStream;
+        /**
+         * The [`Writable`](https://nodejs.org/docs/latest-v22.x/api/stream.html#writable-streams) stream to write readline data to.
+         */
         output?: NodeJS.WritableStream | undefined;
+        /**
+         * An optional function used for Tab autocompletion.
+         */
         completer?: Completer | AsyncCompleter | undefined;
+        /**
+         * `true` if the `input` and `output` streams should be treated like a TTY,
+         * and have ANSI/VT100 escape codes written to it.
+         * Default: checking `isTTY` on the `output` stream upon instantiation.
+         */
         terminal?: boolean | undefined;
         /**
-         *  Initial list of history lines. This option makes sense
-         * only if `terminal` is set to `true` by the user or by an internal `output`
-         * check, otherwise the history caching mechanism is not initialized at all.
+         * Initial list of history lines.
+         * This option makes sense only if `terminal` is set to `true` by the user or by an internal `output` check,
+         * otherwise the history caching mechanism is not initialized at all.
          * @default []
          */
         history?: string[] | undefined;
+        /**
+         * Maximum number of history lines retained.
+         * To disable the history set this value to `0`.
+         * This option makes sense only if `terminal` is set to `true` by the user or by an internal `output` check,
+         * otherwise the history caching mechanism is not initialized at all.
+         * @default 30
+         */
         historySize?: number | undefined;
-        prompt?: string | undefined;
-        crlfDelay?: number | undefined;
         /**
-         * If `true`, when a new input line added
-         * to the history list duplicates an older one, this removes the older line
-         * from the list.
+         * If `true`, when a new input line added to the history list duplicates an older one,
+         * this removes the older line from the list.
          * @default false
          */
         removeHistoryDuplicates?: boolean | undefined;
+        /**
+         * The prompt string to use.
+         * @default "> "
+         */
+        prompt?: string | undefined;
+        /**
+         * If the delay between `\r` and `\n` exceeds `crlfDelay` milliseconds,
+         * both `\r` and `\n` will be treated as separate end-of-line input.
+         * `crlfDelay` will be coerced to a number no less than `100`.
+         * It can be set to `Infinity`, in which case
+         * `\r` followed by `\n` will always be considered a single newline
+         * (which may be reasonable for [reading files](https://nodejs.org/docs/latest-v22.x/api/readline.html#example-read-file-stream-line-by-line) with `\r\n` line delimiter).
+         * @default 100
+         */
+        crlfDelay?: number | undefined;
+        /**
+         * The duration `readline` will wait for a character
+         * (when reading an ambiguous key sequence in milliseconds
+         * one that can both form a complete key sequence using the input read so far
+         * and can take additional input to complete a longer key sequence).
+         * @default 500
+         */
         escapeCodeTimeout?: number | undefined;
+        /**
+         * The number of spaces a tab is equal to (minimum 1).
+         * @default 8
+         */
         tabSize?: number | undefined;
+        /**
+         * Allows closing the interface using an AbortSignal.
+         * Aborting the signal will internally call `close` on the interface.
+         */
+        signal?: AbortSignal | undefined;
     }
     /**
      * The `readline.createInterface()` method creates a new `readline.Interface` instance.

node/test.d.ts

@@ -1796,6 +1796,25 @@ interface TestCoverage {
                 count: number;
             }>;
         }>;
+        /**
+         * An object containing whether or not the coverage for
+         * each coverage type.
+         * @since v22.9.0
+         */
+        thresholds: {
+            /**
+             * The function coverage threshold.
+             */
+            function: number;
+            /**
+             * The branch coverage threshold.
+             */
+            branch: number;
+            /**
+             * The line coverage threshold.
+             */
+            line: number;
+        };
         /**
          * An object containing a summary of coverage for all files.
          */

node/timers/promises.d.ts

@@ -80,7 +80,7 @@ declare module "timers/promises" {
          * @experimental
          * @param [delay=1] The number of milliseconds to wait before fulfilling the promise.
          */
-        wait: (delay?: number, options?: Pick<TimerOptions, "signal">) => Promise<void>;
+        wait: (delay?: number, options?: TimerOptions) => Promise<void>;
         /**
          * An experimental API defined by the [Scheduling APIs](https://nodejs.org/docs/latest-v20.x/api/async_hooks.html#promise-execution-tracking) draft specification
          * being developed as a standard Web Platform API.

node/tls.d.ts

@@ -809,6 +809,12 @@ declare module "tls" {
          * This option cannot be used with the `ALPNProtocols` option, and setting both options will throw an error.
          */
         ALPNCallback?: ((arg: { servername: string; protocols: string[] }) => string | undefined) | undefined;
+        /**
+         * Treat intermediate (non-self-signed)
+         * certificates in the trust CA certificate list as trusted.
+         * @since v22.9.0, v20.18.0
+         */
+        allowPartialTrustChain?: boolean | undefined;
         /**
          * Optionally override the trusted CA certificates. Default is to trust
          * the well-known CAs curated by Mozilla. Mozilla's CAs are completely

node/util.d.ts

@@ -108,6 +108,25 @@ declare module "util" {
     export interface InspectOptionsStylized extends InspectOptions {
         stylize(text: string, styleType: Style): string;
     }
+    export interface StacktraceObject {
+        /**
+         * Returns the name of the function associated with this stack frame.
+         */
+        functionName: string;
+        /**
+         * Returns the name of the resource that contains the script for the
+         * function for this StackFrame.
+         */
+        scriptName: string;
+        /**
+         * Returns the number, 1-based, of the line for the associate function call.
+         */
+        lineNumber: number;
+        /**
+         * Returns the 1-based column offset on the line for the associated function call.
+         */
+        column: number;
+    }
     /**
      * The `util.format()` method returns a formatted string using the first argument
      * as a `printf`-like format string which can contain zero or more format
@@ -166,6 +185,52 @@ declare module "util" {
      * @since v10.0.0
      */
     export function formatWithOptions(inspectOptions: InspectOptions, format?: any, ...param: any[]): string;
+    /**
+     * Returns an array of stacktrace objects containing the stack of
+     * the caller function.
+     *
+     * ```js
+     * const util = require('node:util');
+     *
+     * function exampleFunction() {
+     *   const callSites = util.getCallSite();
+     *
+     *   console.log('Call Sites:');
+     *   callSites.forEach((callSite, index) => {
+     *     console.log(`CallSite ${index + 1}:`);
+     *     console.log(`Function Name: ${callSite.functionName}`);
+     *     console.log(`Script Name: ${callSite.scriptName}`);
+     *     console.log(`Line Number: ${callSite.lineNumber}`);
+     *     console.log(`Column Number: ${callSite.column}`);
+     *   });
+     *   // CallSite 1:
+     *   // Function Name: exampleFunction
+     *   // Script Name: /home/example.js
+     *   // Line Number: 5
+     *   // Column Number: 26
+     *
+     *   // CallSite 2:
+     *   // Function Name: anotherFunction
+     *   // Script Name: /home/example.js
+     *   // Line Number: 22
+     *   // Column Number: 3
+     *
+     *   // ...
+     * }
+     *
+     * // A function to simulate another stack layer
+     * function anotherFunction() {
+     *   exampleFunction();
+     * }
+     *
+     * anotherFunction();
+     * ```
+     * @param frames Number of frames returned in the stacktrace.
+     * **Default:** `10`. Allowable range is between 1 and 200.
+     * @return An array of stacktrace objects
+     * @since v22.9.0
+     */
+    export function getCallSite(frames?: number): StacktraceObject[];
     /**
      * Returns the string name for a numeric error code that comes from a Node.js API.
      * The mapping between error codes and error names is platform-dependent.