@types/node 22.15.33 → 24.10.3

{node v22.15 → node v24.10}/https.d.ts

@@ -1,27 +1,25 @@
 /**
  * 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/v22.x/lib/https.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/https.js)
  */
 declare module "https" {
+    import { NonSharedBuffer } from "node:buffer";
     import { Duplex } from "node:stream";
     import * as tls from "node:tls";
     import * as http from "node:http";
     import { URL } from "node:url";
-    type ServerOptions<
+    interface ServerOptions<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
         Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse,
-    > = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions<Request, Response>;
-    type RequestOptions =
-        & http.RequestOptions
-        & tls.SecureContextOptions
-        & {
-            checkServerIdentity?:
-                | ((hostname: string, cert: tls.DetailedPeerCertificate) => Error | undefined)
-                | undefined;
-            rejectUnauthorized?: boolean | undefined; // Defaults to true
-            servername?: string | undefined; // SNI TLS Extension
-        };
+    > extends http.ServerOptions<Request, Response>, tls.TlsOptions {}
+    interface RequestOptions extends http.RequestOptions, tls.SecureContextOptions {
+        checkServerIdentity?:
+            | ((hostname: string, cert: tls.DetailedPeerCertificate) => Error | undefined)
+            | undefined;
+        rejectUnauthorized?: boolean | undefined; // Defaults to true
+        servername?: string | undefined; // SNI TLS Extension
+    }
     interface AgentOptions extends http.AgentOptions, tls.ConnectionOptions {
         maxCachedSessions?: number | undefined;
     }
@@ -32,6 +30,11 @@ declare module "https" {
     class Agent extends http.Agent {
         constructor(options?: AgentOptions);
         options: AgentOptions;
+        createConnection(
+            options: RequestOptions,
+            callback?: (err: Error | null, stream: Duplex) => void,
+        ): Duplex | null | undefined;
+        getName(options?: RequestOptions): string;
     }
     interface Server<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
@@ -61,22 +64,25 @@ 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: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
         addListener(
             event: "newSession",
-            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
         ): this;
         addListener(
             event: "OCSPRequest",
             listener: (
-                certificate: Buffer,
-                issuer: Buffer,
-                callback: (err: Error | null, resp: Buffer) => void,
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
             ) => void,
         ): this;
         addListener(
             event: "resumeSession",
-            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => void,
+            ) => void,
         ): this;
         addListener(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
         addListener(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
@@ -89,28 +95,32 @@ declare module "https" {
         addListener(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
         addListener(
             event: "connect",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
         ): this;
         addListener(event: "request", listener: http.RequestListener<Request, Response>): this;
         addListener(
             event: "upgrade",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
         ): this;
         emit(event: string, ...args: any[]): boolean;
-        emit(event: "keylog", line: Buffer, tlsSocket: tls.TLSSocket): boolean;
+        emit(event: "keylog", line: NonSharedBuffer, tlsSocket: tls.TLSSocket): boolean;
         emit(
             event: "newSession",
-            sessionId: Buffer,
-            sessionData: Buffer,
-            callback: (err: Error, resp: Buffer) => void,
+            sessionId: NonSharedBuffer,
+            sessionData: NonSharedBuffer,
+            callback: () => void,
         ): boolean;
         emit(
             event: "OCSPRequest",
-            certificate: Buffer,
-            issuer: Buffer,
-            callback: (err: Error | null, resp: Buffer) => void,
+            certificate: NonSharedBuffer,
+            issuer: NonSharedBuffer,
+            callback: (err: Error | null, resp: Buffer | null) => void,
+        ): boolean;
+        emit(
+            event: "resumeSession",
+            sessionId: NonSharedBuffer,
+            callback: (err: Error | null, sessionData: Buffer | null) => 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;
         emit(event: "close"): boolean;
@@ -128,30 +138,33 @@ declare module "https" {
             res: InstanceType<Response>,
         ): boolean;
         emit(event: "clientError", err: Error, socket: Duplex): boolean;
-        emit(event: "connect", req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
+        emit(event: "connect", req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer): boolean;
         emit(
             event: "request",
             req: InstanceType<Request>,
             res: InstanceType<Response>,
         ): boolean;
-        emit(event: "upgrade", req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
+        emit(event: "upgrade", req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
-        on(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        on(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
         on(
             event: "newSession",
-            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
         ): this;
         on(
             event: "OCSPRequest",
             listener: (
-                certificate: Buffer,
-                issuer: Buffer,
-                callback: (err: Error | null, resp: Buffer) => void,
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
             ) => void,
         ): this;
         on(
             event: "resumeSession",
-            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => void,
+            ) => void,
         ): this;
         on(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
         on(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
@@ -162,26 +175,35 @@ declare module "https" {
         on(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
         on(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
         on(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
-        on(event: "connect", listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        on(
+            event: "connect",
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
+        ): this;
         on(event: "request", listener: http.RequestListener<Request, Response>): this;
-        on(event: "upgrade", listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        on(
+            event: "upgrade",
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
+        ): this;
         once(event: string, listener: (...args: any[]) => void): this;
-        once(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        once(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
         once(
             event: "newSession",
-            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
         ): this;
         once(
             event: "OCSPRequest",
             listener: (
-                certificate: Buffer,
-                issuer: Buffer,
-                callback: (err: Error | null, resp: Buffer) => void,
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
             ) => void,
         ): this;
         once(
             event: "resumeSession",
-            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => void,
+            ) => void,
         ): this;
         once(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
         once(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
@@ -192,26 +214,35 @@ declare module "https" {
         once(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
         once(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
         once(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
-        once(event: "connect", listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        once(
+            event: "connect",
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
+        ): this;
         once(event: "request", listener: http.RequestListener<Request, Response>): this;
-        once(event: "upgrade", listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        once(
+            event: "upgrade",
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
+        ): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
-        prependListener(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        prependListener(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
         prependListener(
             event: "newSession",
-            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
         ): this;
         prependListener(
             event: "OCSPRequest",
             listener: (
-                certificate: Buffer,
-                issuer: Buffer,
-                callback: (err: Error | null, resp: Buffer) => void,
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
             ) => void,
         ): this;
         prependListener(
             event: "resumeSession",
-            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => void,
+            ) => void,
         ): this;
         prependListener(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
         prependListener(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
@@ -224,30 +255,33 @@ declare module "https" {
         prependListener(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
         prependListener(
             event: "connect",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
         ): this;
         prependListener(event: "request", listener: http.RequestListener<Request, Response>): this;
         prependListener(
             event: "upgrade",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
         ): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
+        prependOnceListener(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
         prependOnceListener(
             event: "newSession",
-            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
         ): this;
         prependOnceListener(
             event: "OCSPRequest",
             listener: (
-                certificate: Buffer,
-                issuer: Buffer,
-                callback: (err: Error | null, resp: Buffer) => void,
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
             ) => void,
         ): this;
         prependOnceListener(
             event: "resumeSession",
-            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => void,
+            ) => void,
         ): this;
         prependOnceListener(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
         prependOnceListener(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
@@ -260,12 +294,12 @@ declare module "https" {
         prependOnceListener(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
         prependOnceListener(
             event: "connect",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
         ): this;
         prependOnceListener(event: "request", listener: http.RequestListener<Request, Response>): this;
         prependOnceListener(
             event: "upgrade",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
         ): this;
     }
     /**

{node v22.15 → node v24.10}/index.d.ts

@@ -22,20 +22,30 @@
  * IN THE SOFTWARE.
  */
 
-// NOTE: These definitions support Node.js and TypeScript 5.7+.
+// NOTE: These definitions support Node.js and TypeScript 5.8+.
 
-// Reference required TypeScript libs:
+// Reference required TypeScript libraries:
 /// <reference lib="es2020" />
+/// <reference lib="esnext.disposable" />
+/// <reference lib="esnext.float16" />
 
-// TypeScript backwards-compatibility definitions:
-/// <reference path="compatibility/index.d.ts" />
+// Iterator definitions required for compatibility with TypeScript <5.6:
+/// <reference path="compatibility/iterators.d.ts" />
 
-// Definitions specific to TypeScript 5.7+:
+// Definitions for Node.js modules specific to TypeScript 5.7+:
 /// <reference path="globals.typedarray.d.ts" />
 /// <reference path="buffer.buffer.d.ts" />
 
 // Definitions for Node.js modules that are not specific to any version of TypeScript:
 /// <reference path="globals.d.ts" />
+/// <reference path="web-globals/abortcontroller.d.ts" />
+/// <reference path="web-globals/crypto.d.ts" />
+/// <reference path="web-globals/domexception.d.ts" />
+/// <reference path="web-globals/events.d.ts" />
+/// <reference path="web-globals/fetch.d.ts" />
+/// <reference path="web-globals/navigator.d.ts" />
+/// <reference path="web-globals/storage.d.ts" />
+/// <reference path="web-globals/streams.d.ts" />
 /// <reference path="assert.d.ts" />
 /// <reference path="assert/strict.d.ts" />
 /// <reference path="async_hooks.d.ts" />
@@ -49,9 +59,7 @@
 /// <reference path="diagnostics_channel.d.ts" />
 /// <reference path="dns.d.ts" />
 /// <reference path="dns/promises.d.ts" />
-/// <reference path="dns/promises.d.ts" />
 /// <reference path="domain.d.ts" />
-/// <reference path="dom-events.d.ts" />
 /// <reference path="events.d.ts" />
 /// <reference path="fs.d.ts" />
 /// <reference path="fs/promises.d.ts" />
@@ -59,6 +67,7 @@
 /// <reference path="http2.d.ts" />
 /// <reference path="https.d.ts" />
 /// <reference path="inspector.d.ts" />
+/// <reference path="inspector.generated.d.ts" />
 /// <reference path="module.d.ts" />
 /// <reference path="net.d.ts" />
 /// <reference path="os.d.ts" />

node v24.10/inspector.d.ts

@@ -0,0 +1,277 @@
+/**
+ * The `node:inspector` module provides an API for interacting with the V8
+ * inspector.
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/inspector.js)
+ */
+declare module "inspector" {
+    import EventEmitter = require("node:events");
+    /**
+     * The `inspector.Session` is used for dispatching messages to the V8 inspector
+     * back-end and receiving message responses and notifications.
+     */
+    class Session extends EventEmitter {
+        /**
+         * Create a new instance of the inspector.Session class.
+         * The inspector session needs to be connected through `session.connect()` before the messages can be dispatched to the inspector backend.
+         */
+        constructor();
+        /**
+         * Connects a session to the inspector back-end.
+         */
+        connect(): void;
+        /**
+         * Connects a session to the inspector back-end.
+         * An exception will be thrown if this API was not called on a Worker thread.
+         * @since v12.11.0
+         */
+        connectToMainThread(): void;
+        /**
+         * Immediately close the session. All pending message callbacks will be called with an error.
+         * `session.connect()` will need to be called to be able to send messages again.
+         * Reconnected session will lose all inspector state, such as enabled agents or configured breakpoints.
+         */
+        disconnect(): void;
+    }
+    /**
+     * Activate inspector on host and port. Equivalent to `node --inspect=[[host:]port]`, but can be done programmatically after node has
+     * started.
+     *
+     * If wait is `true`, will block until a client has connected to the inspect port
+     * and flow control has been passed to the debugger client.
+     *
+     * See the [security warning](https://nodejs.org/docs/latest-v24.x/api/cli.html#warning-binding-inspector-to-a-public-ipport-combination-is-insecure)
+     * regarding the `host` parameter usage.
+     * @param port Port to listen on for inspector connections. Defaults to what was specified on the CLI.
+     * @param host Host to listen on for inspector connections. Defaults to what was specified on the CLI.
+     * @param wait Block until a client has connected. Defaults to what was specified on the CLI.
+     * @returns Disposable that calls `inspector.close()`.
+     */
+    function open(port?: number, host?: string, wait?: boolean): Disposable;
+    /**
+     * Deactivate the inspector. Blocks until there are no active connections.
+     */
+    function close(): void;
+    /**
+     * Return the URL of the active inspector, or `undefined` if there is none.
+     *
+     * ```console
+     * $ node --inspect -p 'inspector.url()'
+     * Debugger listening on ws://127.0.0.1:9229/166e272e-7a30-4d09-97ce-f1c012b43c34
+     * For help, see: https://nodejs.org/en/docs/inspector
+     * ws://127.0.0.1:9229/166e272e-7a30-4d09-97ce-f1c012b43c34
+     *
+     * $ node --inspect=localhost:3000 -p 'inspector.url()'
+     * Debugger listening on ws://localhost:3000/51cf8d0e-3c36-4c59-8efd-54519839e56a
+     * For help, see: https://nodejs.org/en/docs/inspector
+     * ws://localhost:3000/51cf8d0e-3c36-4c59-8efd-54519839e56a
+     *
+     * $ node -p 'inspector.url()'
+     * undefined
+     * ```
+     */
+    function url(): string | undefined;
+    /**
+     * Blocks until a client (existing or connected later) has sent `Runtime.runIfWaitingForDebugger` command.
+     *
+     * An exception will be thrown if there is no active inspector.
+     * @since v12.7.0
+     */
+    function waitForDebugger(): void;
+    // These methods are exposed by the V8 inspector console API (inspector/v8-console.h).
+    // The method signatures differ from those of the Node.js console, and are deliberately
+    // typed permissively.
+    interface InspectorConsole {
+        debug(...data: any[]): void;
+        error(...data: any[]): void;
+        info(...data: any[]): void;
+        log(...data: any[]): void;
+        warn(...data: any[]): void;
+        dir(...data: any[]): void;
+        dirxml(...data: any[]): void;
+        table(...data: any[]): void;
+        trace(...data: any[]): void;
+        group(...data: any[]): void;
+        groupCollapsed(...data: any[]): void;
+        groupEnd(...data: any[]): void;
+        clear(...data: any[]): void;
+        count(label?: any): void;
+        countReset(label?: any): void;
+        assert(value?: any, ...data: any[]): void;
+        profile(label?: any): void;
+        profileEnd(label?: any): void;
+        time(label?: any): void;
+        timeLog(label?: any): void;
+        timeStamp(label?: any): void;
+    }
+    /**
+     * An object to send messages to the remote inspector console.
+     * @since v11.0.0
+     */
+    const console: InspectorConsole;
+    // DevTools protocol event broadcast methods
+    namespace Network {
+        /**
+         * 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
+         */
+        function requestWillBeSent(params: RequestWillBeSentEventDataType): void;
+        /**
+         * 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.
+         *
+         * Also enables `Network.getResponseBody` command to retrieve the response data.
+         * @since v24.2.0
+         */
+        function dataReceived(params: DataReceivedEventDataType): void;
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Enables `Network.getRequestPostData` command to retrieve the request data.
+         * @since v24.3.0
+         */
+        function dataSent(params: unknown): void;
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Broadcasts the `Network.responseReceived` event to connected frontends. This event indicates that
+         * HTTP response is available.
+         * @since v22.6.0
+         */
+        function responseReceived(params: ResponseReceivedEventDataType): void;
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Broadcasts the `Network.loadingFinished` event to connected frontends. This event indicates that
+         * HTTP request has finished loading.
+         * @since v22.6.0
+         */
+        function loadingFinished(params: LoadingFinishedEventDataType): void;
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Broadcasts the `Network.loadingFailed` event to connected frontends. This event indicates that
+         * HTTP request has failed to load.
+         * @since v22.7.0
+         */
+        function loadingFailed(params: LoadingFailedEventDataType): void;
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Broadcasts the `Network.webSocketCreated` event to connected frontends. This event indicates that
+         * a WebSocket connection has been initiated.
+         * @since v24.7.0
+         */
+        function webSocketCreated(params: WebSocketCreatedEventDataType): void;
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Broadcasts the `Network.webSocketHandshakeResponseReceived` event to connected frontends.
+         * This event indicates that the WebSocket handshake response has been received.
+         * @since v24.7.0
+         */
+        function webSocketHandshakeResponseReceived(params: WebSocketHandshakeResponseReceivedEventDataType): void;
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Broadcasts the `Network.webSocketClosed` event to connected frontends.
+         * This event indicates that a WebSocket connection has been closed.
+         * @since v24.7.0
+         */
+        function webSocketClosed(params: WebSocketClosedEventDataType): void;
+    }
+    namespace NetworkResources {
+        /**
+         * This feature is only available with the `--experimental-inspector-network-resource` flag enabled.
+         *
+         * The inspector.NetworkResources.put method is used to provide a response for a loadNetworkResource
+         * request issued via the Chrome DevTools Protocol (CDP).
+         * This is typically triggered when a source map is specified by URL, and a DevTools frontend—such as
+         * Chrome—requests the resource to retrieve the source map.
+         *
+         * This method allows developers to predefine the resource content to be served in response to such CDP requests.
+         *
+         * ```js
+         * const inspector = require('node:inspector');
+         * // By preemptively calling put to register the resource, a source map can be resolved when
+         * // a loadNetworkResource request is made from the frontend.
+         * async function setNetworkResources() {
+         *   const mapUrl = 'http://localhost:3000/dist/app.js.map';
+         *   const tsUrl = 'http://localhost:3000/src/app.ts';
+         *   const distAppJsMap = await fetch(mapUrl).then((res) => res.text());
+         *   const srcAppTs = await fetch(tsUrl).then((res) => res.text());
+         *   inspector.NetworkResources.put(mapUrl, distAppJsMap);
+         *   inspector.NetworkResources.put(tsUrl, srcAppTs);
+         * };
+         * setNetworkResources().then(() => {
+         *   require('./dist/app');
+         * });
+         * ```
+         *
+         * For more details, see the official CDP documentation: [Network.loadNetworkResource](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-loadNetworkResource)
+         * @since v24.5.0
+         * @experimental
+         */
+        function put(url: string, data: string): void;
+    }
+}
+
+/**
+ * The `node:inspector` module provides an API for interacting with the V8
+ * inspector.
+ */
+declare module "node:inspector" {
+    export * from "inspector";
+}
+
+/**
+ * The `node:inspector/promises` module provides an API for interacting with the V8
+ * inspector.
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/inspector/promises.js)
+ * @since v19.0.0
+ */
+declare module "inspector/promises" {
+    import EventEmitter = require("node:events");
+    export { close, console, NetworkResources, open, url, waitForDebugger } from "inspector";
+    /**
+     * The `inspector.Session` is used for dispatching messages to the V8 inspector
+     * back-end and receiving message responses and notifications.
+     * @since v19.0.0
+     */
+    export class Session extends EventEmitter {
+        /**
+         * Create a new instance of the inspector.Session class.
+         * The inspector session needs to be connected through `session.connect()` before the messages can be dispatched to the inspector backend.
+         */
+        constructor();
+        /**
+         * Connects a session to the inspector back-end.
+         */
+        connect(): void;
+        /**
+         * Connects a session to the inspector back-end.
+         * An exception will be thrown if this API was not called on a Worker thread.
+         * @since v12.11.0
+         */
+        connectToMainThread(): void;
+        /**
+         * Immediately close the session. All pending message callbacks will be called with an error.
+         * `session.connect()` will need to be called to be able to send messages again.
+         * Reconnected session will lose all inspector state, such as enabled agents or configured breakpoints.
+         */
+        disconnect(): void;
+    }
+}
+
+/**
+ * The `node:inspector/promises` module provides an API for interacting with the V8
+ * inspector.
+ * @since v19.0.0
+ */
+declare module "node:inspector/promises" {
+    export * from "inspector/promises";
+}