@types/node 22.16.4 → 22.17.0

{node v22.16 → node v22.17}/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/v22.
 
 ### Additional Details
- * Last updated: Tue, 15 Jul 2025 07:04:18 GMT
+ * Last updated: Tue, 29 Jul 2025 15:04:17 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

{node v22.16 → node v22.17}/buffer.d.ts

@@ -118,7 +118,6 @@ declare module "buffer" {
      * Resolves a `'blob:nodedata:...'` an associated `Blob` object registered using
      * a prior call to `URL.createObjectURL()`.
      * @since v16.7.0
-     * @experimental
      * @param id A `'blob:nodedata:...` URL string returned by a prior call to `URL.createObjectURL()`.
      */
     export function resolveObjectURL(id: string): Blob | undefined;

{node v22.16 → node v22.17}/crypto.d.ts

@@ -3764,7 +3764,23 @@ declare module "crypto" {
          */
         checkIP(ip: string): string | undefined;
         /**
-         * Checks whether this certificate was issued by the given `otherCert`.
+         * Checks whether this certificate was potentially issued by the given `otherCert`
+         * by comparing the certificate metadata.
+         *
+         * This is useful for pruning a list of possible issuer certificates which have been
+         * selected using a more rudimentary filtering routine, i.e. just based on subject
+         * and issuer names.
+         *
+         * Finally, to verify that this certificate's signature was produced by a private key
+         * corresponding to `otherCert`'s public key use `x509.verify(publicKey)`
+         * with `otherCert`'s public key represented as a `KeyObject`
+         * like so
+         *
+         * ```js
+         * if (!x509.verify(otherCert.publicKey)) {
+         *   throw new Error('otherCert did not issue x509');
+         * }
+         * ```
          * @since v15.6.0
          */
         checkIssued(otherCert: X509Certificate): boolean;

{node v22.16 → node v22.17}/fs/promises.d.ts

@@ -88,6 +88,9 @@ declare module "fs/promises" {
         highWaterMark?: number | undefined;
         flush?: boolean | undefined;
     }
+    interface ReadableWebStreamOptions {
+        autoClose?: boolean | undefined;
+    }
     // TODO: Add `EventEmitter` close
     interface FileHandle {
         /**
@@ -260,9 +263,8 @@ declare module "fs/promises" {
          * While the `ReadableStream` will read the file to completion, it will not
          * close the `FileHandle` automatically. User code must still call the`fileHandle.close()` method.
          * @since v17.0.0
-         * @experimental
          */
-        readableWebStream(): ReadableStream;
+        readableWebStream(options?: ReadableWebStreamOptions): ReadableStream;
         /**
          * Asynchronously reads the entire contents of a file.
          *
@@ -475,7 +477,8 @@ declare module "fs/promises" {
          */
         close(): Promise<void>;
         /**
-         * An alias for {@link FileHandle.close()}.
+         * Calls `filehandle.close()` and returns a promise that fulfills when the
+         * filehandle is closed.
          * @since v20.4.0
          */
         [Symbol.asyncDispose](): Promise<void>;
@@ -1252,20 +1255,28 @@ declare module "fs/promises" {
      */
     function cp(source: string | URL, destination: string | URL, opts?: CopyOptions): Promise<void>;
     /**
-     * Retrieves the files matching the specified pattern.
+     * ```js
+     * import { glob } from 'node:fs/promises';
+     *
+     * for await (const entry of glob('*.js'))
+     *   console.log(entry);
+     * ```
+     * @since v22.0.0
+     * @returns An AsyncIterator that yields the paths of files
+     * that match the pattern.
      */
-    function glob(pattern: string | string[]): NodeJS.AsyncIterator<string>;
+    function glob(pattern: string | readonly string[]): NodeJS.AsyncIterator<string>;
     function glob(
-        pattern: string | string[],
-        opt: GlobOptionsWithFileTypes,
+        pattern: string | readonly string[],
+        options: GlobOptionsWithFileTypes,
     ): NodeJS.AsyncIterator<Dirent>;
     function glob(
-        pattern: string | string[],
-        opt: GlobOptionsWithoutFileTypes,
+        pattern: string | readonly string[],
+        options: GlobOptionsWithoutFileTypes,
     ): NodeJS.AsyncIterator<string>;
     function glob(
-        pattern: string | string[],
-        opt: GlobOptions,
+        pattern: string | readonly string[],
+        options: GlobOptions,
     ): NodeJS.AsyncIterator<Dirent | string>;
 }
 declare module "node:fs/promises" {

{node v22.16 → node v22.17}/fs.d.ts

@@ -243,8 +243,8 @@ declare module "fs" {
          */
         name: Name;
         /**
-         * The base path that this `fs.Dirent` object refers to.
-         * @since v20.12.0
+         * The path to the parent directory of the file this `fs.Dirent` object refers to.
+         * @since v20.12.0, v18.20.0
          */
         parentPath: string;
         /**
@@ -328,6 +328,19 @@ declare module "fs" {
          * @since v12.12.0
          */
         readSync(): Dirent | null;
+        /**
+         * Calls `dir.close()` and returns a promise that fulfills when the
+         * dir is closed.
+         * @since v22.17.0
+         * @experimental
+         */
+        [Symbol.asyncDispose](): Promise<void>;
+        /**
+         * Calls `dir.closeSync()` and returns `undefined`.
+         * @since v22.17.0
+         * @experimental
+         */
+        [Symbol.dispose](): void;
     }
     /**
      * Class: fs.StatWatcher
@@ -4200,7 +4213,6 @@ declare module "fs" {
      * blob.stream();
      * ```
      * @since v19.8.0
-     * @experimental
      */
     export function openAsBlob(path: PathLike, options?: OpenAsBlobOptions): Promise<Blob>;
 
@@ -4361,7 +4373,7 @@ declare module "fs" {
          * Current working directory.
          * @default process.cwd()
          */
-        cwd?: string | undefined;
+        cwd?: string | URL | undefined;
         /**
          * `true` if the glob should return paths as `Dirent`s, `false` otherwise.
          * @default false
@@ -4386,13 +4398,23 @@ declare module "fs" {
 
     /**
      * Retrieves the files matching the specified pattern.
+     *
+     * ```js
+     * import { glob } from 'node:fs';
+     *
+     * glob('*.js', (err, matches) => {
+     *   if (err) throw err;
+     *   console.log(matches);
+     * });
+     * ```
+     * @since v22.0.0
      */
     export function glob(
-        pattern: string | string[],
+        pattern: string | readonly string[],
         callback: (err: NodeJS.ErrnoException | null, matches: string[]) => void,
     ): void;
     export function glob(
-        pattern: string | string[],
+        pattern: string | readonly string[],
         options: GlobOptionsWithFileTypes,
         callback: (
             err: NodeJS.ErrnoException | null,
@@ -4400,7 +4422,7 @@ declare module "fs" {
         ) => void,
     ): void;
     export function glob(
-        pattern: string | string[],
+        pattern: string | readonly string[],
         options: GlobOptionsWithoutFileTypes,
         callback: (
             err: NodeJS.ErrnoException | null,
@@ -4408,7 +4430,7 @@ declare module "fs" {
         ) => void,
     ): void;
     export function glob(
-        pattern: string | string[],
+        pattern: string | readonly string[],
         options: GlobOptions,
         callback: (
             err: NodeJS.ErrnoException | null,
@@ -4416,19 +4438,25 @@ declare module "fs" {
         ) => void,
     ): void;
     /**
-     * Retrieves the files matching the specified pattern.
+     * ```js
+     * import { globSync } from 'node:fs';
+     *
+     * console.log(globSync('*.js'));
+     * ```
+     * @since v22.0.0
+     * @returns paths of files that match the pattern.
      */
-    export function globSync(pattern: string | string[]): string[];
+    export function globSync(pattern: string | readonly string[]): string[];
     export function globSync(
-        pattern: string | string[],
+        pattern: string | readonly string[],
         options: GlobOptionsWithFileTypes,
     ): Dirent[];
     export function globSync(
-        pattern: string | string[],
+        pattern: string | readonly string[],
         options: GlobOptionsWithoutFileTypes,
     ): string[];
     export function globSync(
-        pattern: string | string[],
+        pattern: string | readonly string[],
         options: GlobOptions,
     ): Dirent[] | string[];
 }

{node v22.16 → node v22.17}/http.d.ts

@@ -911,7 +911,7 @@ declare module "http" {
          * the request body should be sent.
          * @since v10.0.0
          */
-        writeProcessing(): void;
+        writeProcessing(callback?: () => void): void;
     }
     interface InformationEvent {
         statusCode: number;

{node v22.16 → node v22.17}/http2.d.ts

@@ -965,7 +965,10 @@ declare module "http2" {
          * * `:path` \= `/`
          * @since v8.4.0
          */
-        request(headers?: OutgoingHttpHeaders, options?: ClientSessionRequestOptions): ClientHttp2Stream;
+        request(
+            headers?: OutgoingHttpHeaders | readonly string[],
+            options?: ClientSessionRequestOptions,
+        ): ClientHttp2Stream;
         addListener(event: "altsvc", listener: (alt: string, origin: string, stream: number) => void): this;
         addListener(event: "origin", listener: (origins: string[]) => void): this;
         addListener(
@@ -1291,6 +1294,14 @@ declare module "http2" {
          * @default 100000
          */
         unknownProtocolTimeout?: number | undefined;
+        /**
+         * If `true`, it turns on strict leading
+         * and trailing whitespace validation for HTTP/2 header field names and values
+         * as per [RFC-9113](https://www.rfc-editor.org/rfc/rfc9113.html#section-8.2.1).
+         * @since v24.2.0
+         * @default true
+         */
+        strictFieldWhitespaceValidation?: boolean | undefined;
     }
     export interface ClientSessionOptions extends SessionOptions {
         /**

{node v22.16 → node v22.17}/inspector.d.ts

@@ -1768,12 +1768,26 @@ declare module 'inspector' {
             status: number;
             statusText: string;
             headers: Headers;
+            mimeType: string;
+            charset: string;
         }
         /**
          * Request / response headers as keys / values of JSON object.
          */
         interface Headers {
         }
+        interface StreamResourceContentParameterType {
+            /**
+             * Identifier of the request to stream.
+             */
+            requestId: RequestId;
+        }
+        interface StreamResourceContentReturnType {
+            /**
+             * Data that has been buffered until streaming is enabled.
+             */
+            bufferedData: never;
+        }
         interface RequestWillBeSentEventDataType {
             /**
              * Request identifier.
@@ -1842,12 +1856,59 @@ declare module 'inspector' {
              */
             timestamp: MonotonicTime;
         }
+        interface DataReceivedEventDataType {
+            /**
+             * Request identifier.
+             */
+            requestId: RequestId;
+            /**
+             * Timestamp.
+             */
+            timestamp: MonotonicTime;
+            /**
+             * Data chunk length.
+             */
+            dataLength: number;
+            /**
+             * Actual bytes received (might be less than dataLength for compressed encodings).
+             */
+            encodedDataLength: number;
+            /**
+             * Data that was received.
+             * @experimental
+             */
+            data?: never | undefined;
+        }
     }
     namespace NodeRuntime {
         interface NotifyWhenWaitingForDisconnectParameterType {
             enabled: boolean;
         }
     }
+    namespace Target {
+        type SessionID = string;
+        type TargetID = string;
+        interface TargetInfo {
+            targetId: TargetID;
+            type: string;
+            title: string;
+            url: string;
+            attached: boolean;
+            canAccessOpener: boolean;
+        }
+        interface SetAutoAttachParameterType {
+            autoAttach: boolean;
+            waitForDebuggerOnStart: boolean;
+        }
+        interface TargetCreatedEventDataType {
+            targetInfo: TargetInfo;
+        }
+        interface AttachedToTargetEventDataType {
+            sessionId: SessionID;
+            targetInfo: TargetInfo;
+            waitingForDebugger: boolean;
+        }
+    }
 
     /**
      * The `inspector.Session` is used for dispatching messages to the V8 inspector
@@ -2224,6 +2285,17 @@ declare module 'inspector' {
          * Enables network tracking, network events will now be delivered to the client.
          */
         post(method: 'Network.enable', callback?: (err: Error | null) => void): void;
+        /**
+         * Enables streaming of the response for the given requestId.
+         * If enabled, the dataReceived event contains the data that was received during streaming.
+         * @experimental
+         */
+        post(
+            method: 'Network.streamResourceContent',
+            params?: Network.StreamResourceContentParameterType,
+            callback?: (err: Error | null, params: Network.StreamResourceContentReturnType) => void
+        ): void;
+        post(method: 'Network.streamResourceContent', callback?: (err: Error | null, params: Network.StreamResourceContentReturnType) => void): void;
         /**
          * Enable the NodeRuntime events except by `NodeRuntime.waitingForDisconnect`.
          */
@@ -2237,6 +2309,8 @@ declare module 'inspector' {
          */
         post(method: 'NodeRuntime.notifyWhenWaitingForDisconnect', params?: NodeRuntime.NotifyWhenWaitingForDisconnectParameterType, callback?: (err: Error | null) => void): void;
         post(method: 'NodeRuntime.notifyWhenWaitingForDisconnect', callback?: (err: Error | null) => void): void;
+        post(method: 'Target.setAutoAttach', params?: Target.SetAutoAttachParameterType, callback?: (err: Error | null) => void): void;
+        post(method: 'Target.setAutoAttach', callback?: (err: Error | null) => void): void;
 
         addListener(event: string, listener: (...args: any[]) => void): this;
         /**
@@ -2343,6 +2417,10 @@ declare module 'inspector' {
         addListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
         addListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
         addListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
+        /**
+         * Fired when data chunk was received over the network.
+         */
+        addListener(event: 'Network.dataReceived', listener: (message: InspectorNotification<Network.DataReceivedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2355,6 +2433,8 @@ declare module 'inspector' {
          * example, when inspector.waitingForDebugger is called
          */
         addListener(event: 'NodeRuntime.waitingForDebugger', listener: () => void): this;
+        addListener(event: 'Target.targetCreated', listener: (message: InspectorNotification<Target.TargetCreatedEventDataType>) => void): this;
+        addListener(event: 'Target.attachedToTarget', listener: (message: InspectorNotification<Target.AttachedToTargetEventDataType>) => void): this;
         emit(event: string | symbol, ...args: any[]): boolean;
         emit(event: 'inspectorNotification', message: InspectorNotification<object>): boolean;
         emit(event: 'Runtime.executionContextCreated', message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>): boolean;
@@ -2386,8 +2466,11 @@ declare module 'inspector' {
         emit(event: 'Network.responseReceived', message: InspectorNotification<Network.ResponseReceivedEventDataType>): boolean;
         emit(event: 'Network.loadingFailed', message: InspectorNotification<Network.LoadingFailedEventDataType>): boolean;
         emit(event: 'Network.loadingFinished', message: InspectorNotification<Network.LoadingFinishedEventDataType>): boolean;
+        emit(event: 'Network.dataReceived', message: InspectorNotification<Network.DataReceivedEventDataType>): boolean;
         emit(event: 'NodeRuntime.waitingForDisconnect'): boolean;
         emit(event: 'NodeRuntime.waitingForDebugger'): boolean;
+        emit(event: 'Target.targetCreated', message: InspectorNotification<Target.TargetCreatedEventDataType>): boolean;
+        emit(event: 'Target.attachedToTarget', message: InspectorNotification<Target.AttachedToTargetEventDataType>): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
         /**
          * Emitted when any notification from the V8 Inspector is received.
@@ -2493,6 +2576,10 @@ declare module 'inspector' {
         on(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
         on(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
         on(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
+        /**
+         * Fired when data chunk was received over the network.
+         */
+        on(event: 'Network.dataReceived', listener: (message: InspectorNotification<Network.DataReceivedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2505,6 +2592,8 @@ declare module 'inspector' {
          * example, when inspector.waitingForDebugger is called
          */
         on(event: 'NodeRuntime.waitingForDebugger', listener: () => void): this;
+        on(event: 'Target.targetCreated', listener: (message: InspectorNotification<Target.TargetCreatedEventDataType>) => void): this;
+        on(event: 'Target.attachedToTarget', listener: (message: InspectorNotification<Target.AttachedToTargetEventDataType>) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
         /**
          * Emitted when any notification from the V8 Inspector is received.
@@ -2610,6 +2699,10 @@ declare module 'inspector' {
         once(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
         once(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
         once(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
+        /**
+         * Fired when data chunk was received over the network.
+         */
+        once(event: 'Network.dataReceived', listener: (message: InspectorNotification<Network.DataReceivedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2622,6 +2715,8 @@ declare module 'inspector' {
          * example, when inspector.waitingForDebugger is called
          */
         once(event: 'NodeRuntime.waitingForDebugger', listener: () => void): this;
+        once(event: 'Target.targetCreated', listener: (message: InspectorNotification<Target.TargetCreatedEventDataType>) => void): this;
+        once(event: 'Target.attachedToTarget', listener: (message: InspectorNotification<Target.AttachedToTargetEventDataType>) => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
         /**
          * Emitted when any notification from the V8 Inspector is received.
@@ -2727,6 +2822,10 @@ declare module 'inspector' {
         prependListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
         prependListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
         prependListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
+        /**
+         * Fired when data chunk was received over the network.
+         */
+        prependListener(event: 'Network.dataReceived', listener: (message: InspectorNotification<Network.DataReceivedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2739,6 +2838,8 @@ declare module 'inspector' {
          * example, when inspector.waitingForDebugger is called
          */
         prependListener(event: 'NodeRuntime.waitingForDebugger', listener: () => void): this;
+        prependListener(event: 'Target.targetCreated', listener: (message: InspectorNotification<Target.TargetCreatedEventDataType>) => void): this;
+        prependListener(event: 'Target.attachedToTarget', listener: (message: InspectorNotification<Target.AttachedToTargetEventDataType>) => void): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         /**
          * Emitted when any notification from the V8 Inspector is received.
@@ -2844,6 +2945,10 @@ declare module 'inspector' {
         prependOnceListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
         prependOnceListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
         prependOnceListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
+        /**
+         * Fired when data chunk was received over the network.
+         */
+        prependOnceListener(event: 'Network.dataReceived', listener: (message: InspectorNotification<Network.DataReceivedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2856,6 +2961,8 @@ declare module 'inspector' {
          * example, when inspector.waitingForDebugger is called
          */
         prependOnceListener(event: 'NodeRuntime.waitingForDebugger', listener: () => void): this;
+        prependOnceListener(event: 'Target.targetCreated', listener: (message: InspectorNotification<Target.TargetCreatedEventDataType>) => void): this;
+        prependOnceListener(event: 'Target.attachedToTarget', listener: (message: InspectorNotification<Target.AttachedToTargetEventDataType>) => void): this;
     }
 
     /**
@@ -2942,13 +3049,20 @@ declare module 'inspector' {
 
     // DevTools protocol event broadcast methods
     namespace Network {
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Broadcasts the `Network.dataReceived` event to connected frontends, or buffers the data if
+         * `Network.streamResourceContent` command was not invoked for the given request yet.
+         * @since v22.17.0
+         */
+        function dataReceived(params: DataReceivedEventDataType): void;
         /**
          * This feature is only available with the `--experimental-network-inspection` flag enabled.
          *
          * Broadcasts the `Network.requestWillBeSent` event to connected frontends. This event indicates that
          * the application is about to send an HTTP request.
          * @since v22.6.0
-         * @experimental
          */
         function requestWillBeSent(params: RequestWillBeSentEventDataType): void;
         /**
@@ -2957,7 +3071,6 @@ declare module 'inspector' {
          * Broadcasts the `Network.responseReceived` event to connected frontends. This event indicates that
          * HTTP response is available.
          * @since v22.6.0
-         * @experimental
          */
         function responseReceived(params: ResponseReceivedEventDataType): void;
         /**
@@ -2966,7 +3079,6 @@ declare module 'inspector' {
          * Broadcasts the `Network.loadingFinished` event to connected frontends. This event indicates that
          * HTTP request has finished loading.
          * @since v22.6.0
-         * @experimental
          */
         function loadingFinished(params: LoadingFinishedEventDataType): void;
         /**
@@ -2975,7 +3087,6 @@ declare module 'inspector' {
          * Broadcasts the `Network.loadingFailed` event to connected frontends. This event indicates that
          * HTTP request has failed to load.
          * @since v22.7.0
-         * @experimental
          */
         function loadingFailed(params: LoadingFailedEventDataType): void;
     }
@@ -3014,6 +3125,7 @@ declare module 'inspector/promises' {
         NodeWorker,
         Network,
         NodeRuntime,
+        Target,
     } from 'inspector';
 
     /**
@@ -3338,6 +3450,12 @@ declare module 'inspector/promises' {
          * Enables network tracking, network events will now be delivered to the client.
          */
         post(method: 'Network.enable'): Promise<void>;
+        /**
+         * Enables streaming of the response for the given requestId.
+         * If enabled, the dataReceived event contains the data that was received during streaming.
+         * @experimental
+         */
+        post(method: 'Network.streamResourceContent', params?: Network.StreamResourceContentParameterType): Promise<Network.StreamResourceContentReturnType>;
         /**
          * Enable the NodeRuntime events except by `NodeRuntime.waitingForDisconnect`.
          */
@@ -3350,6 +3468,7 @@ declare module 'inspector/promises' {
          * Enable the `NodeRuntime.waitingForDisconnect`.
          */
         post(method: 'NodeRuntime.notifyWhenWaitingForDisconnect', params?: NodeRuntime.NotifyWhenWaitingForDisconnectParameterType): Promise<void>;
+        post(method: 'Target.setAutoAttach', params?: Target.SetAutoAttachParameterType): Promise<void>;
 
         addListener(event: string, listener: (...args: any[]) => void): this;
         /**
@@ -3456,6 +3575,10 @@ declare module 'inspector/promises' {
         addListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
         addListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
         addListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
+        /**
+         * Fired when data chunk was received over the network.
+         */
+        addListener(event: 'Network.dataReceived', listener: (message: InspectorNotification<Network.DataReceivedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3468,6 +3591,8 @@ declare module 'inspector/promises' {
          * example, when inspector.waitingForDebugger is called
          */
         addListener(event: 'NodeRuntime.waitingForDebugger', listener: () => void): this;
+        addListener(event: 'Target.targetCreated', listener: (message: InspectorNotification<Target.TargetCreatedEventDataType>) => void): this;
+        addListener(event: 'Target.attachedToTarget', listener: (message: InspectorNotification<Target.AttachedToTargetEventDataType>) => void): this;
         emit(event: string | symbol, ...args: any[]): boolean;
         emit(event: 'inspectorNotification', message: InspectorNotification<object>): boolean;
         emit(event: 'Runtime.executionContextCreated', message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>): boolean;
@@ -3499,8 +3624,11 @@ declare module 'inspector/promises' {
         emit(event: 'Network.responseReceived', message: InspectorNotification<Network.ResponseReceivedEventDataType>): boolean;
         emit(event: 'Network.loadingFailed', message: InspectorNotification<Network.LoadingFailedEventDataType>): boolean;
         emit(event: 'Network.loadingFinished', message: InspectorNotification<Network.LoadingFinishedEventDataType>): boolean;
+        emit(event: 'Network.dataReceived', message: InspectorNotification<Network.DataReceivedEventDataType>): boolean;
         emit(event: 'NodeRuntime.waitingForDisconnect'): boolean;
         emit(event: 'NodeRuntime.waitingForDebugger'): boolean;
+        emit(event: 'Target.targetCreated', message: InspectorNotification<Target.TargetCreatedEventDataType>): boolean;
+        emit(event: 'Target.attachedToTarget', message: InspectorNotification<Target.AttachedToTargetEventDataType>): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
         /**
          * Emitted when any notification from the V8 Inspector is received.
@@ -3606,6 +3734,10 @@ declare module 'inspector/promises' {
         on(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
         on(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
         on(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
+        /**
+         * Fired when data chunk was received over the network.
+         */
+        on(event: 'Network.dataReceived', listener: (message: InspectorNotification<Network.DataReceivedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3618,6 +3750,8 @@ declare module 'inspector/promises' {
          * example, when inspector.waitingForDebugger is called
          */
         on(event: 'NodeRuntime.waitingForDebugger', listener: () => void): this;
+        on(event: 'Target.targetCreated', listener: (message: InspectorNotification<Target.TargetCreatedEventDataType>) => void): this;
+        on(event: 'Target.attachedToTarget', listener: (message: InspectorNotification<Target.AttachedToTargetEventDataType>) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
         /**
          * Emitted when any notification from the V8 Inspector is received.
@@ -3723,6 +3857,10 @@ declare module 'inspector/promises' {
         once(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
         once(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
         once(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
+        /**
+         * Fired when data chunk was received over the network.
+         */
+        once(event: 'Network.dataReceived', listener: (message: InspectorNotification<Network.DataReceivedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3735,6 +3873,8 @@ declare module 'inspector/promises' {
          * example, when inspector.waitingForDebugger is called
          */
         once(event: 'NodeRuntime.waitingForDebugger', listener: () => void): this;
+        once(event: 'Target.targetCreated', listener: (message: InspectorNotification<Target.TargetCreatedEventDataType>) => void): this;
+        once(event: 'Target.attachedToTarget', listener: (message: InspectorNotification<Target.AttachedToTargetEventDataType>) => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
         /**
          * Emitted when any notification from the V8 Inspector is received.
@@ -3840,6 +3980,10 @@ declare module 'inspector/promises' {
         prependListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
         prependListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
         prependListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
+        /**
+         * Fired when data chunk was received over the network.
+         */
+        prependListener(event: 'Network.dataReceived', listener: (message: InspectorNotification<Network.DataReceivedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3852,6 +3996,8 @@ declare module 'inspector/promises' {
          * example, when inspector.waitingForDebugger is called
          */
         prependListener(event: 'NodeRuntime.waitingForDebugger', listener: () => void): this;
+        prependListener(event: 'Target.targetCreated', listener: (message: InspectorNotification<Target.TargetCreatedEventDataType>) => void): this;
+        prependListener(event: 'Target.attachedToTarget', listener: (message: InspectorNotification<Target.AttachedToTargetEventDataType>) => void): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         /**
          * Emitted when any notification from the V8 Inspector is received.
@@ -3957,6 +4103,10 @@ declare module 'inspector/promises' {
         prependOnceListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
         prependOnceListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
         prependOnceListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
+        /**
+         * Fired when data chunk was received over the network.
+         */
+        prependOnceListener(event: 'Network.dataReceived', listener: (message: InspectorNotification<Network.DataReceivedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3969,6 +4119,8 @@ declare module 'inspector/promises' {
          * example, when inspector.waitingForDebugger is called
          */
         prependOnceListener(event: 'NodeRuntime.waitingForDebugger', listener: () => void): this;
+        prependOnceListener(event: 'Target.targetCreated', listener: (message: InspectorNotification<Target.TargetCreatedEventDataType>) => void): this;
+        prependOnceListener(event: 'Target.attachedToTarget', listener: (message: InspectorNotification<Target.AttachedToTargetEventDataType>) => void): this;
     }
 
     export {
@@ -3989,6 +4141,7 @@ declare module 'inspector/promises' {
         NodeWorker,
         Network,
         NodeRuntime,
+        Target,
     };
 }
 

{node v22.16 → node v22.17}/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "22.16.4",
+    "version": "22.17.0",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -140,6 +140,6 @@
         "undici-types": "~6.21.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "d301d67133c8a5db8e1653ffa1a0a1a0c7f3ce7a52a3031731407c635ef09fb8",
+    "typesPublisherContentHash": "00d5bad9b7d88013ca5b7f270921b6bb4fd9c32ccc73d840855525aafc6f1fe8",
     "typeScriptVersion": "5.1"
 }

{node v22.16 → node v22.17}/readline/promises.d.ts

@@ -1,6 +1,5 @@
 /**
  * @since v17.0.0
- * @experimental
  */
 declare module "readline/promises" {
     import { Abortable } from "node:events";

{node v22.16 → node v22.17}/stream.d.ts

@@ -76,7 +76,6 @@ declare module "stream" {
             /**
              * A utility method for creating a `Readable` from a web `ReadableStream`.
              * @since v17.0.0
-             * @experimental
              */
             static fromWeb(
                 readableStream: streamWeb.ReadableStream,
@@ -85,7 +84,6 @@ declare module "stream" {
             /**
              * A utility method for creating a web `ReadableStream` from a `Readable`.
              * @since v17.0.0
-             * @experimental
              */
             static toWeb(
                 streamReadable: Readable,
@@ -101,7 +99,6 @@ declare module "stream" {
             /**
              * Returns whether the stream was destroyed or errored before emitting `'end'`.
              * @since v16.8.0
-             * @experimental
              */
             readonly readableAborted: boolean;
             /**
@@ -113,7 +110,6 @@ declare module "stream" {
             /**
              * Returns whether `'data'` has been emitted.
              * @since v16.7.0, v14.18.0
-             * @experimental
              */
             readonly readableDidRead: boolean;
             /**
@@ -719,7 +715,6 @@ declare module "stream" {
             /**
              * A utility method for creating a `Writable` from a web `WritableStream`.
              * @since v17.0.0
-             * @experimental
              */
             static fromWeb(
                 writableStream: streamWeb.WritableStream,
@@ -728,7 +723,6 @@ declare module "stream" {
             /**
              * A utility method for creating a web `WritableStream` from a `Writable`.
              * @since v17.0.0
-             * @experimental
              */
             static toWeb(streamWritable: Writable): streamWeb.WritableStream;
             /**
@@ -740,7 +734,6 @@ declare module "stream" {
             /**
              * Returns whether the stream was destroyed or errored before emitting `'finish'`.
              * @since v18.0.0, v16.17.0
-             * @experimental
              */
             readonly writableAborted: boolean;
             /**
@@ -1090,7 +1083,6 @@ declare module "stream" {
             /**
              * A utility method for creating a web `ReadableStream` and `WritableStream` from a `Duplex`.
              * @since v17.0.0
-             * @experimental
              */
             static toWeb(streamDuplex: Duplex): {
                 readable: streamWeb.ReadableStream;
@@ -1099,7 +1091,6 @@ declare module "stream" {
             /**
              * A utility method for creating a `Duplex` from a web `ReadableStream` and `WritableStream`.
              * @since v17.0.0
-             * @experimental
              */
             static fromWeb(
                 duplexStream: {
@@ -1650,13 +1641,11 @@ declare module "stream" {
         /**
          * Returns whether the stream has encountered an error.
          * @since v17.3.0, v16.14.0
-         * @experimental
          */
         function isErrored(stream: Readable | Writable | NodeJS.ReadableStream | NodeJS.WritableStream): boolean;
         /**
          * Returns whether the stream is readable.
          * @since v17.4.0, v16.14.0
-         * @experimental
          */
         function isReadable(stream: Readable | NodeJS.ReadableStream): boolean;
     }

{node v22.16 → node v22.17}/test.d.ts

@@ -502,6 +502,14 @@ declare module "node:test" {
                  * The nesting level of the test.
                  */
                 nesting: number;
+                /**
+                 * The severity level of the diagnostic message.
+                 * Possible values are:
+                 * * `'info'`: Informational messages.
+                 * * `'warn'`: Warnings.
+                 * * `'error'`: Errors.
+                 */
+                level: "info" | "warn" | "error";
             }
             interface TestCoverage {
                 /**

{node v22.16 → node v22.17}/url.d.ts

@@ -420,14 +420,12 @@ declare module "url" {
          * Threads, `Blob` objects registered within one Worker will not be available
          * to other workers or the main thread.
          * @since v16.7.0
-         * @experimental
          */
         static createObjectURL(blob: NodeBlob): string;
         /**
          * Removes the stored `Blob` identified by the given ID. Attempting to revoke a
          * ID that isn't registered will silently fail.
          * @since v16.7.0
-         * @experimental
          * @param id A `'blob:nodedata:...` URL string returned by a prior call to `URL.createObjectURL()`.
          */
         static revokeObjectURL(id: string): void;
@@ -828,7 +826,7 @@ declare module "url" {
          * Returns an ES6 `Iterator` over each of the name-value pairs in the query.
          * Each item of the iterator is a JavaScript `Array`. The first item of the `Array` is the `name`, the second item of the `Array` is the `value`.
          *
-         * Alias for `urlSearchParams[@@iterator]()`.
+         * Alias for `urlSearchParams[Symbol.iterator]()`.
          */
         entries(): URLSearchParamsIterator<[string, string]>;
         /**

{node v22.16 → node v22.17}/util.d.ts

@@ -444,8 +444,8 @@ declare module "util" {
      * intended for debugging. The output of `util.inspect` may change at any time
      * and should not be depended upon programmatically. Additional `options` may be
      * passed that alter the result.
-     * `util.inspect()` will use the constructor's name and/or `@@toStringTag` to make
-     * an identifiable tag for an inspected value.
+     * `util.inspect()` will use the constructor's name and/or `Symbol.toStringTag`
+     * property to make an identifiable tag for an inspected value.
      *
      * ```js
      * class Foo {
@@ -1461,6 +1461,7 @@ declare module "util" {
         | "hidden"
         | "inverse"
         | "italic"
+        | "none"
         | "overlined"
         | "reset"
         | "strikethrough"
@@ -1517,6 +1518,8 @@ declare module "util" {
      * );
      * ```
      *
+     * The special format value `none` applies no additional styling to the text.
+     *
      * The full list of formats can be found in [modifiers](https://nodejs.org/docs/latest-v22.x/api/util.html#modifiers).
      * @param format A text format or an Array of text formats defined in `util.inspect.colors`.
      * @param text The text to to be formatted.

{node v22.16 → node v22.17}/v8.d.ts

@@ -581,7 +581,6 @@ declare module "v8" {
     /**
      * The API is a no-op if `--heapsnapshot-near-heap-limit` is already set from the command line or the API is called more than once.
      * `limit` must be a positive integer. See [`--heapsnapshot-near-heap-limit`](https://nodejs.org/docs/latest-v22.x/api/cli.html#--heapsnapshot-near-heap-limitmax_count) for more information.
-     * @experimental
      * @since v18.10.0, v16.18.0
      */
     function setHeapSnapshotNearHeapLimit(limit: number): void;
@@ -807,33 +806,6 @@ declare module "v8" {
      */
     const promiseHooks: PromiseHooks;
     type StartupSnapshotCallbackFn = (args: any) => any;
-    interface StartupSnapshot {
-        /**
-         * Add a callback that will be called when the Node.js instance is about to get serialized into a snapshot and exit.
-         * This can be used to release resources that should not or cannot be serialized or to convert user data into a form more suitable for serialization.
-         * @since v18.6.0, v16.17.0
-         */
-        addSerializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void;
-        /**
-         * Add a callback that will be called when the Node.js instance is deserialized from a snapshot.
-         * The `callback` and the `data` (if provided) will be serialized into the snapshot, they can be used to re-initialize the state of the application or
-         * to re-acquire resources that the application needs when the application is restarted from the snapshot.
-         * @since v18.6.0, v16.17.0
-         */
-        addDeserializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void;
-        /**
-         * This sets the entry point of the Node.js application when it is deserialized from a snapshot. This can be called only once in the snapshot building script.
-         * If called, the deserialized application no longer needs an additional entry point script to start up and will simply invoke the callback along with the deserialized
-         * data (if provided), otherwise an entry point script still needs to be provided to the deserialized application.
-         * @since v18.6.0, v16.17.0
-         */
-        setDeserializeMainFunction(callback: StartupSnapshotCallbackFn, data?: any): void;
-        /**
-         * Returns true if the Node.js instance is run to build a snapshot.
-         * @since v18.6.0, v16.17.0
-         */
-        isBuildingSnapshot(): boolean;
-    }
     /**
      * The `v8.startupSnapshot` interface can be used to add serialization and deserialization hooks for custom startup snapshots.
      *
@@ -912,10 +884,35 @@ declare module "v8" {
      *
      * Currently the application deserialized from a user-land snapshot cannot be snapshotted again, so these APIs are only available to applications that are not deserialized from a user-land snapshot.
      *
-     * @experimental
      * @since v18.6.0, v16.17.0
      */
-    const startupSnapshot: StartupSnapshot;
+    namespace startupSnapshot {
+        /**
+         * Add a callback that will be called when the Node.js instance is about to get serialized into a snapshot and exit.
+         * This can be used to release resources that should not or cannot be serialized or to convert user data into a form more suitable for serialization.
+         * @since v18.6.0, v16.17.0
+         */
+        function addSerializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void;
+        /**
+         * Add a callback that will be called when the Node.js instance is deserialized from a snapshot.
+         * The `callback` and the `data` (if provided) will be serialized into the snapshot, they can be used to re-initialize the state of the application or
+         * to re-acquire resources that the application needs when the application is restarted from the snapshot.
+         * @since v18.6.0, v16.17.0
+         */
+        function addDeserializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void;
+        /**
+         * This sets the entry point of the Node.js application when it is deserialized from a snapshot. This can be called only once in the snapshot building script.
+         * If called, the deserialized application no longer needs an additional entry point script to start up and will simply invoke the callback along with the deserialized
+         * data (if provided), otherwise an entry point script still needs to be provided to the deserialized application.
+         * @since v18.6.0, v16.17.0
+         */
+        function setDeserializeMainFunction(callback: StartupSnapshotCallbackFn, data?: any): void;
+        /**
+         * Returns true if the Node.js instance is run to build a snapshot.
+         * @since v18.6.0, v16.17.0
+         */
+        function isBuildingSnapshot(): boolean;
+    }
 }
 declare module "node:v8" {
     export * from "v8";

{node v22.16 → node v22.17}/worker_threads.d.ts

@@ -187,6 +187,11 @@ declare module "worker_threads" {
          * @since v10.5.0
          */
         postMessage(value: any, transferList?: readonly Transferable[]): void;
+        /**
+         * If true, the `MessagePort` object will keep the Node.js event loop active.
+         * @since v18.1.0, v16.17.0
+         */
+        hasRef(): boolean;
         /**
          * Opposite of `unref()`. Calling `ref()` on a previously `unref()`ed port does _not_ let the program exit if it's the only active handle left (the default
          * behavior). If the port is `ref()`ed, calling `ref()` again has no effect.

{node v22.16 → node v22.17}/zlib.d.ts

@@ -147,6 +147,10 @@ declare module "zlib" {
          * @default buffer.kMaxLength
          */
         maxOutputLength?: number | undefined;
+        /**
+         * If `true`, returns an object with `buffer` and `engine`.
+         */
+        info?: boolean | undefined;
     }
     interface ZstdOptions {
         /**
@@ -172,6 +176,10 @@ declare module "zlib" {
          * @default buffer.kMaxLength
          */
         maxOutputLength?: number | undefined;
+        /**
+         * If `true`, returns an object with `buffer` and `engine`.
+         */
+        info?: boolean | undefined;
     }
     interface Zlib {
         /** @deprecated Use bytesWritten instead. */
@@ -612,8 +620,6 @@ declare module "zlib" {
     const Z_FINISH: number;
     /** @deprecated Use `constants.Z_BLOCK` */
     const Z_BLOCK: number;
-    /** @deprecated Use `constants.Z_TREES` */
-    const Z_TREES: number;
     // Return codes for the compression/decompression functions.
     // Negative values are errors, positive values are used for special but normal events.
     /** @deprecated Use `constants.Z_OK` */