@types/node 25.3.5 → 25.4.0

node/inspector.generated.d.ts

@@ -1620,79 +1620,38 @@ declare module "node:inspector" {
             statsUpdate: number[];
         }
     }
-    namespace NodeTracing {
-        interface TraceConfig {
-            /**
-             * Controls how the trace buffer stores data.
-             */
-            recordMode?: string | undefined;
-            /**
-             * Included category filters.
-             */
-            includedCategories: string[];
-        }
-        interface StartParameterType {
-            traceConfig: TraceConfig;
-        }
-        interface GetCategoriesReturnType {
+    namespace IO {
+        type StreamHandle = string;
+        interface ReadParameterType {
             /**
-             * A list of supported tracing categories.
+             * Handle of the stream to read.
              */
-            categories: string[];
-        }
-        interface DataCollectedEventDataType {
-            value: object[];
-        }
-    }
-    namespace NodeWorker {
-        type WorkerID = string;
-        /**
-         * Unique identifier of attached debugging session.
-         */
-        type SessionID = string;
-        interface WorkerInfo {
-            workerId: WorkerID;
-            type: string;
-            title: string;
-            url: string;
-        }
-        interface SendMessageToWorkerParameterType {
-            message: string;
+            handle: StreamHandle;
             /**
-             * Identifier of the session.
+             * Seek to the specified offset before reading (if not specified, proceed with offset
+             * following the last read). Some types of streams may only support sequential reads.
              */
-            sessionId: SessionID;
-        }
-        interface EnableParameterType {
+            offset?: number | undefined;
             /**
-             * Whether to new workers should be paused until the frontend sends `Runtime.runIfWaitingForDebugger`
-             * message to run them.
+             * Maximum number of bytes to read (left upon the agent discretion if not specified).
              */
-            waitForDebuggerOnStart: boolean;
-        }
-        interface DetachParameterType {
-            sessionId: SessionID;
+            size?: number | undefined;
         }
-        interface AttachedToWorkerEventDataType {
+        interface CloseParameterType {
             /**
-             * Identifier assigned to the session used to send/receive messages.
+             * Handle of the stream to close.
              */
-            sessionId: SessionID;
-            workerInfo: WorkerInfo;
-            waitingForDebugger: boolean;
+            handle: StreamHandle;
         }
-        interface DetachedFromWorkerEventDataType {
+        interface ReadReturnType {
             /**
-             * Detached session identifier.
+             * Data that were read.
              */
-            sessionId: SessionID;
-        }
-        interface ReceivedMessageFromWorkerEventDataType {
+            data: string;
             /**
-             * Identifier of a session which sends a message.
+             * Set if the end-of-file condition occurred while reading.
              */
-            sessionId: SessionID;
-            message: string;
+            eof: boolean;
         }
     }
     namespace Network {
@@ -1790,6 +1749,18 @@ declare module "node:inspector" {
              */
             headers: Headers;
         }
+        interface EnableParameterType {
+            /**
+             * Buffer size in bytes to use when preserving network payloads (XHRs, etc).
+             * @experimental
+             */
+            maxTotalBufferSize?: number | undefined;
+            /**
+             * Per-resource buffer size in bytes to use when preserving network payloads (XHRs, etc).
+             * @experimental
+             */
+            maxResourceBufferSize?: number | undefined;
+        }
         interface GetRequestPostDataParameterType {
             /**
              * Identifier of the network request to get content for.
@@ -1974,6 +1945,81 @@ declare module "node:inspector" {
             enabled: boolean;
         }
     }
+    namespace NodeTracing {
+        interface TraceConfig {
+            /**
+             * Controls how the trace buffer stores data.
+             */
+            recordMode?: string | undefined;
+            /**
+             * Included category filters.
+             */
+            includedCategories: string[];
+        }
+        interface StartParameterType {
+            traceConfig: TraceConfig;
+        }
+        interface GetCategoriesReturnType {
+            /**
+             * A list of supported tracing categories.
+             */
+            categories: string[];
+        }
+        interface DataCollectedEventDataType {
+            value: object[];
+        }
+    }
+    namespace NodeWorker {
+        type WorkerID = string;
+        /**
+         * Unique identifier of attached debugging session.
+         */
+        type SessionID = string;
+        interface WorkerInfo {
+            workerId: WorkerID;
+            type: string;
+            title: string;
+            url: string;
+        }
+        interface SendMessageToWorkerParameterType {
+            message: string;
+            /**
+             * Identifier of the session.
+             */
+            sessionId: SessionID;
+        }
+        interface EnableParameterType {
+            /**
+             * Whether to new workers should be paused until the frontend sends `Runtime.runIfWaitingForDebugger`
+             * message to run them.
+             */
+            waitForDebuggerOnStart: boolean;
+        }
+        interface DetachParameterType {
+            sessionId: SessionID;
+        }
+        interface AttachedToWorkerEventDataType {
+            /**
+             * Identifier assigned to the session used to send/receive messages.
+             */
+            sessionId: SessionID;
+            workerInfo: WorkerInfo;
+            waitingForDebugger: boolean;
+        }
+        interface DetachedFromWorkerEventDataType {
+            /**
+             * Detached session identifier.
+             */
+            sessionId: SessionID;
+        }
+        interface ReceivedMessageFromWorkerEventDataType {
+            /**
+             * Identifier of a session which sends a message.
+             */
+            sessionId: SessionID;
+            message: string;
+        }
+    }
     namespace Target {
         type SessionID = string;
         type TargetID = string;
@@ -1998,40 +2044,6 @@ declare module "node:inspector" {
             waitingForDebugger: boolean;
         }
     }
-    namespace IO {
-        type StreamHandle = string;
-        interface ReadParameterType {
-            /**
-             * Handle of the stream to read.
-             */
-            handle: StreamHandle;
-            /**
-             * Seek to the specified offset before reading (if not specified, proceed with offset
-             * following the last read). Some types of streams may only support sequential reads.
-             */
-            offset?: number | undefined;
-            /**
-             * Maximum number of bytes to read (left upon the agent discretion if not specified).
-             */
-            size?: number | undefined;
-        }
-        interface CloseParameterType {
-            /**
-             * Handle of the stream to close.
-             */
-            handle: StreamHandle;
-        }
-        interface ReadReturnType {
-            /**
-             * Data that were read.
-             */
-            data: string;
-            /**
-             * Set if the end-of-file condition occurred while reading.
-             */
-            eof: boolean;
-        }
-    }
     interface Session {
         /**
          * Posts a message to the inspector back-end. `callback` will be notified when
@@ -2337,39 +2349,12 @@ declare module "node:inspector" {
         post(method: "HeapProfiler.stopSampling", callback?: (err: Error | null, params: HeapProfiler.StopSamplingReturnType) => void): void;
         post(method: "HeapProfiler.getSamplingProfile", callback?: (err: Error | null, params: HeapProfiler.GetSamplingProfileReturnType) => void): void;
         /**
-         * Gets supported tracing categories.
-         */
-        post(method: "NodeTracing.getCategories", callback?: (err: Error | null, params: NodeTracing.GetCategoriesReturnType) => void): void;
-        /**
-         * Start trace events collection.
-         */
-        post(method: "NodeTracing.start", params?: NodeTracing.StartParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "NodeTracing.start", callback?: (err: Error | null) => void): void;
-        /**
-         * Stop trace events collection. Remaining collected events will be sent as a sequence of
-         * dataCollected events followed by tracingComplete event.
-         */
-        post(method: "NodeTracing.stop", callback?: (err: Error | null) => void): void;
-        /**
-         * Sends protocol message over session with given id.
-         */
-        post(method: "NodeWorker.sendMessageToWorker", params?: NodeWorker.SendMessageToWorkerParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "NodeWorker.sendMessageToWorker", callback?: (err: Error | null) => void): void;
-        /**
-         * Instructs the inspector to attach to running workers. Will also attach to new workers
-         * as they start
-         */
-        post(method: "NodeWorker.enable", params?: NodeWorker.EnableParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "NodeWorker.enable", callback?: (err: Error | null) => void): void;
-        /**
-         * Detaches from all running workers and disables attaching to new workers as they are started.
-         */
-        post(method: "NodeWorker.disable", callback?: (err: Error | null) => void): void;
-        /**
-         * Detached from the worker with given sessionId.
+         * Read a chunk of the stream
          */
-        post(method: "NodeWorker.detach", params?: NodeWorker.DetachParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "NodeWorker.detach", callback?: (err: Error | null) => void): void;
+        post(method: "IO.read", params?: IO.ReadParameterType, callback?: (err: Error | null, params: IO.ReadReturnType) => void): void;
+        post(method: "IO.read", callback?: (err: Error | null, params: IO.ReadReturnType) => void): void;
+        post(method: "IO.close", params?: IO.CloseParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "IO.close", callback?: (err: Error | null) => void): void;
         /**
          * Disables network tracking, prevents network events from being sent to the client.
          */
@@ -2377,6 +2362,7 @@ declare module "node:inspector" {
         /**
          * Enables network tracking, network events will now be delivered to the client.
          */
+        post(method: "Network.enable", params?: Network.EnableParameterType, callback?: (err: Error | null) => void): void;
         post(method: "Network.enable", callback?: (err: Error | null) => void): void;
         /**
          * Returns post data sent with the request. Returns an error when no data was sent with the request.
@@ -2417,28 +2403,55 @@ declare module "node: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;
         /**
-         * Read a chunk of the stream
+         * Gets supported tracing categories.
          */
-        post(method: "IO.read", params?: IO.ReadParameterType, callback?: (err: Error | null, params: IO.ReadReturnType) => void): void;
-        post(method: "IO.read", callback?: (err: Error | null, params: IO.ReadReturnType) => void): void;
-        post(method: "IO.close", params?: IO.CloseParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "IO.close", callback?: (err: Error | null) => void): void;
-        addListener(event: string, listener: (...args: any[]) => void): this;
+        post(method: "NodeTracing.getCategories", callback?: (err: Error | null, params: NodeTracing.GetCategoriesReturnType) => void): void;
         /**
-         * Emitted when any notification from the V8 Inspector is received.
+         * Start trace events collection.
          */
-        addListener(event: "inspectorNotification", listener: (message: InspectorNotification<object>) => void): this;
+        post(method: "NodeTracing.start", params?: NodeTracing.StartParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "NodeTracing.start", callback?: (err: Error | null) => void): void;
         /**
-         * Issued when new execution context is created.
+         * Stop trace events collection. Remaining collected events will be sent as a sequence of
+         * dataCollected events followed by tracingComplete event.
          */
-        addListener(event: "Runtime.executionContextCreated", listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+        post(method: "NodeTracing.stop", callback?: (err: Error | null) => void): void;
         /**
-         * Issued when execution context is destroyed.
+         * Sends protocol message over session with given id.
          */
-        addListener(event: "Runtime.executionContextDestroyed", listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+        post(method: "NodeWorker.sendMessageToWorker", params?: NodeWorker.SendMessageToWorkerParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "NodeWorker.sendMessageToWorker", callback?: (err: Error | null) => void): void;
+        /**
+         * Instructs the inspector to attach to running workers. Will also attach to new workers
+         * as they start
+         */
+        post(method: "NodeWorker.enable", params?: NodeWorker.EnableParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "NodeWorker.enable", callback?: (err: Error | null) => void): void;
+        /**
+         * Detaches from all running workers and disables attaching to new workers as they are started.
+         */
+        post(method: "NodeWorker.disable", callback?: (err: Error | null) => void): void;
+        /**
+         * Detached from the worker with given sessionId.
+         */
+        post(method: "NodeWorker.detach", params?: NodeWorker.DetachParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "NodeWorker.detach", 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;
+        /**
+         * Emitted when any notification from the V8 Inspector is received.
+         */
+        addListener(event: "inspectorNotification", listener: (message: InspectorNotification<object>) => void): this;
+        /**
+         * Issued when new execution context is created.
+         */
+        addListener(event: "Runtime.executionContextCreated", listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+        /**
+         * Issued when execution context is destroyed.
+         */
+        addListener(event: "Runtime.executionContextDestroyed", listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
         /**
          * Issued when all executionContexts were cleared in browser
          */
@@ -2499,28 +2512,6 @@ declare module "node:inspector" {
          * If heap objects tracking has been started then backend may send update for one or more fragments
          */
         addListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
-        /**
-         * Contains an bucket of collected trace events.
-         */
-        addListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
-        /**
-         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
-         * delivered via dataCollected events.
-         */
-        addListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
-        /**
-         * Issued when attached to a worker.
-         */
-        addListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
-        /**
-         * Issued when detached from the worker.
-         */
-        addListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
-        /**
-         * Notifies about a new protocol message received from the session
-         * (session ID is provided in attachedToWorker notification).
-         */
-        addListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
         /**
          * Fired when page is about to send HTTP request.
          */
@@ -2559,6 +2550,28 @@ declare module "node:inspector" {
          * example, when inspector.waitingForDebugger is called
          */
         addListener(event: "NodeRuntime.waitingForDebugger", listener: () => void): this;
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        addListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        addListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
+        /**
+         * Issued when attached to a worker.
+         */
+        addListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+        /**
+         * Issued when detached from the worker.
+         */
+        addListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        addListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => 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;
@@ -2583,11 +2596,6 @@ declare module "node:inspector" {
         emit(event: "HeapProfiler.reportHeapSnapshotProgress", message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>): boolean;
         emit(event: "HeapProfiler.lastSeenObjectId", message: InspectorNotification<HeapProfiler.LastSeenObjectIdEventDataType>): boolean;
         emit(event: "HeapProfiler.heapStatsUpdate", message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>): boolean;
-        emit(event: "NodeTracing.dataCollected", message: InspectorNotification<NodeTracing.DataCollectedEventDataType>): boolean;
-        emit(event: "NodeTracing.tracingComplete"): boolean;
-        emit(event: "NodeWorker.attachedToWorker", message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>): boolean;
-        emit(event: "NodeWorker.detachedFromWorker", message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>): boolean;
-        emit(event: "NodeWorker.receivedMessageFromWorker", message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>): boolean;
         emit(event: "Network.requestWillBeSent", message: InspectorNotification<Network.RequestWillBeSentEventDataType>): boolean;
         emit(event: "Network.responseReceived", message: InspectorNotification<Network.ResponseReceivedEventDataType>): boolean;
         emit(event: "Network.loadingFailed", message: InspectorNotification<Network.LoadingFailedEventDataType>): boolean;
@@ -2598,6 +2606,11 @@ declare module "node:inspector" {
         emit(event: "Network.webSocketHandshakeResponseReceived", message: InspectorNotification<Network.WebSocketHandshakeResponseReceivedEventDataType>): boolean;
         emit(event: "NodeRuntime.waitingForDisconnect"): boolean;
         emit(event: "NodeRuntime.waitingForDebugger"): boolean;
+        emit(event: "NodeTracing.dataCollected", message: InspectorNotification<NodeTracing.DataCollectedEventDataType>): boolean;
+        emit(event: "NodeTracing.tracingComplete"): boolean;
+        emit(event: "NodeWorker.attachedToWorker", message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>): boolean;
+        emit(event: "NodeWorker.detachedFromWorker", message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>): boolean;
+        emit(event: "NodeWorker.receivedMessageFromWorker", message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>): 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;
@@ -2673,28 +2686,6 @@ declare module "node:inspector" {
          * If heap objects tracking has been started then backend may send update for one or more fragments
          */
         on(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
-        /**
-         * Contains an bucket of collected trace events.
-         */
-        on(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
-        /**
-         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
-         * delivered via dataCollected events.
-         */
-        on(event: "NodeTracing.tracingComplete", listener: () => void): this;
-        /**
-         * Issued when attached to a worker.
-         */
-        on(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
-        /**
-         * Issued when detached from the worker.
-         */
-        on(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
-        /**
-         * Notifies about a new protocol message received from the session
-         * (session ID is provided in attachedToWorker notification).
-         */
-        on(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
         /**
          * Fired when page is about to send HTTP request.
          */
@@ -2733,6 +2724,28 @@ declare module "node:inspector" {
          * example, when inspector.waitingForDebugger is called
          */
         on(event: "NodeRuntime.waitingForDebugger", listener: () => void): this;
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        on(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        on(event: "NodeTracing.tracingComplete", listener: () => void): this;
+        /**
+         * Issued when attached to a worker.
+         */
+        on(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+        /**
+         * Issued when detached from the worker.
+         */
+        on(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        on(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => 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;
@@ -2808,28 +2821,6 @@ declare module "node:inspector" {
          * If heap objects tracking has been started then backend may send update for one or more fragments
          */
         once(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
-        /**
-         * Contains an bucket of collected trace events.
-         */
-        once(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
-        /**
-         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
-         * delivered via dataCollected events.
-         */
-        once(event: "NodeTracing.tracingComplete", listener: () => void): this;
-        /**
-         * Issued when attached to a worker.
-         */
-        once(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
-        /**
-         * Issued when detached from the worker.
-         */
-        once(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
-        /**
-         * Notifies about a new protocol message received from the session
-         * (session ID is provided in attachedToWorker notification).
-         */
-        once(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
         /**
          * Fired when page is about to send HTTP request.
          */
@@ -2868,6 +2859,28 @@ declare module "node:inspector" {
          * example, when inspector.waitingForDebugger is called
          */
         once(event: "NodeRuntime.waitingForDebugger", listener: () => void): this;
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        once(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        once(event: "NodeTracing.tracingComplete", listener: () => void): this;
+        /**
+         * Issued when attached to a worker.
+         */
+        once(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+        /**
+         * Issued when detached from the worker.
+         */
+        once(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        once(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => 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;
@@ -2943,28 +2956,6 @@ declare module "node:inspector" {
          * If heap objects tracking has been started then backend may send update for one or more fragments
          */
         prependListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
-        /**
-         * Contains an bucket of collected trace events.
-         */
-        prependListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
-        /**
-         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
-         * delivered via dataCollected events.
-         */
-        prependListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
-        /**
-         * Issued when attached to a worker.
-         */
-        prependListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
-        /**
-         * Issued when detached from the worker.
-         */
-        prependListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
-        /**
-         * Notifies about a new protocol message received from the session
-         * (session ID is provided in attachedToWorker notification).
-         */
-        prependListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
         /**
          * Fired when page is about to send HTTP request.
          */
@@ -3003,6 +2994,28 @@ declare module "node:inspector" {
          * example, when inspector.waitingForDebugger is called
          */
         prependListener(event: "NodeRuntime.waitingForDebugger", listener: () => void): this;
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        prependListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        prependListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
+        /**
+         * Issued when attached to a worker.
+         */
+        prependListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+        /**
+         * Issued when detached from the worker.
+         */
+        prependListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        prependListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => 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;
@@ -3078,28 +3091,6 @@ declare module "node:inspector" {
          * If heap objects tracking has been started then backend may send update for one or more fragments
          */
         prependOnceListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
-        /**
-         * Contains an bucket of collected trace events.
-         */
-        prependOnceListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
-        /**
-         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
-         * delivered via dataCollected events.
-         */
-        prependOnceListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
-        /**
-         * Issued when attached to a worker.
-         */
-        prependOnceListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
-        /**
-         * Issued when detached from the worker.
-         */
-        prependOnceListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
-        /**
-         * Notifies about a new protocol message received from the session
-         * (session ID is provided in attachedToWorker notification).
-         */
-        prependOnceListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
         /**
          * Fired when page is about to send HTTP request.
          */
@@ -3138,6 +3129,28 @@ declare module "node:inspector" {
          * example, when inspector.waitingForDebugger is called
          */
         prependOnceListener(event: "NodeRuntime.waitingForDebugger", listener: () => void): this;
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        prependOnceListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        prependOnceListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
+        /**
+         * Issued when attached to a worker.
+         */
+        prependOnceListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+        /**
+         * Issued when detached from the worker.
+         */
+        prependOnceListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        prependOnceListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
         prependOnceListener(event: "Target.targetCreated", listener: (message: InspectorNotification<Target.TargetCreatedEventDataType>) => void): this;
         prependOnceListener(event: "Target.attachedToTarget", listener: (message: InspectorNotification<Target.AttachedToTargetEventDataType>) => void): this;
     }
@@ -3150,12 +3163,12 @@ declare module "node:inspector/promises" {
         Console,
         Profiler,
         HeapProfiler,
-        NodeTracing,
-        NodeWorker,
+        IO,
         Network,
         NodeRuntime,
+        NodeTracing,
+        NodeWorker,
         Target,
-        IO,
     } from 'inspector';
 }
 declare module "node:inspector/promises" {
@@ -3167,12 +3180,12 @@ declare module "node:inspector/promises" {
         Console,
         Profiler,
         HeapProfiler,
-        NodeTracing,
-        NodeWorker,
+        IO,
         Network,
         NodeRuntime,
+        NodeTracing,
+        NodeWorker,
         Target,
-        IO,
     } from "inspector";
     /**
      * The `inspector.Session` is used for dispatching messages to the V8 inspector
@@ -3435,79 +3448,79 @@ declare module "node:inspector/promises" {
         post(method: "HeapProfiler.stopSampling"): Promise<HeapProfiler.StopSamplingReturnType>;
         post(method: "HeapProfiler.getSamplingProfile"): Promise<HeapProfiler.GetSamplingProfileReturnType>;
         /**
-         * Gets supported tracing categories.
+         * Read a chunk of the stream
          */
-        post(method: "NodeTracing.getCategories"): Promise<NodeTracing.GetCategoriesReturnType>;
+        post(method: "IO.read", params?: IO.ReadParameterType): Promise<IO.ReadReturnType>;
+        post(method: "IO.close", params?: IO.CloseParameterType): Promise<void>;
         /**
-         * Start trace events collection.
+         * Disables network tracking, prevents network events from being sent to the client.
          */
-        post(method: "NodeTracing.start", params?: NodeTracing.StartParameterType): Promise<void>;
+        post(method: "Network.disable"): Promise<void>;
         /**
-         * Stop trace events collection. Remaining collected events will be sent as a sequence of
-         * dataCollected events followed by tracingComplete event.
+         * Enables network tracking, network events will now be delivered to the client.
          */
-        post(method: "NodeTracing.stop"): Promise<void>;
+        post(method: "Network.enable", params?: Network.EnableParameterType): Promise<void>;
         /**
-         * Sends protocol message over session with given id.
+         * Returns post data sent with the request. Returns an error when no data was sent with the request.
          */
-        post(method: "NodeWorker.sendMessageToWorker", params?: NodeWorker.SendMessageToWorkerParameterType): Promise<void>;
+        post(method: "Network.getRequestPostData", params?: Network.GetRequestPostDataParameterType): Promise<Network.GetRequestPostDataReturnType>;
         /**
-         * Instructs the inspector to attach to running workers. Will also attach to new workers
-         * as they start
+         * Returns content served for the given request.
          */
-        post(method: "NodeWorker.enable", params?: NodeWorker.EnableParameterType): Promise<void>;
+        post(method: "Network.getResponseBody", params?: Network.GetResponseBodyParameterType): Promise<Network.GetResponseBodyReturnType>;
         /**
-         * Detaches from all running workers and disables attaching to new workers as they are started.
+         * 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: "NodeWorker.disable"): Promise<void>;
+        post(method: "Network.streamResourceContent", params?: Network.StreamResourceContentParameterType): Promise<Network.StreamResourceContentReturnType>;
         /**
-         * Detached from the worker with given sessionId.
+         * Fetches the resource and returns the content.
          */
-        post(method: "NodeWorker.detach", params?: NodeWorker.DetachParameterType): Promise<void>;
+        post(method: "Network.loadNetworkResource", params?: Network.LoadNetworkResourceParameterType): Promise<Network.LoadNetworkResourceReturnType>;
         /**
-         * Disables network tracking, prevents network events from being sent to the client.
+         * Enable the NodeRuntime events except by `NodeRuntime.waitingForDisconnect`.
          */
-        post(method: "Network.disable"): Promise<void>;
+        post(method: "NodeRuntime.enable"): Promise<void>;
         /**
-         * Enables network tracking, network events will now be delivered to the client.
+         * Disable NodeRuntime events
          */
-        post(method: "Network.enable"): Promise<void>;
+        post(method: "NodeRuntime.disable"): Promise<void>;
         /**
-         * Returns post data sent with the request. Returns an error when no data was sent with the request.
+         * Enable the `NodeRuntime.waitingForDisconnect`.
          */
-        post(method: "Network.getRequestPostData", params?: Network.GetRequestPostDataParameterType): Promise<Network.GetRequestPostDataReturnType>;
+        post(method: "NodeRuntime.notifyWhenWaitingForDisconnect", params?: NodeRuntime.NotifyWhenWaitingForDisconnectParameterType): Promise<void>;
         /**
-         * Returns content served for the given request.
+         * Gets supported tracing categories.
          */
-        post(method: "Network.getResponseBody", params?: Network.GetResponseBodyParameterType): Promise<Network.GetResponseBodyReturnType>;
+        post(method: "NodeTracing.getCategories"): Promise<NodeTracing.GetCategoriesReturnType>;
         /**
-         * Enables streaming of the response for the given requestId.
-         * If enabled, the dataReceived event contains the data that was received during streaming.
-         * @experimental
+         * Start trace events collection.
          */
-        post(method: "Network.streamResourceContent", params?: Network.StreamResourceContentParameterType): Promise<Network.StreamResourceContentReturnType>;
+        post(method: "NodeTracing.start", params?: NodeTracing.StartParameterType): Promise<void>;
         /**
-         * Fetches the resource and returns the content.
+         * Stop trace events collection. Remaining collected events will be sent as a sequence of
+         * dataCollected events followed by tracingComplete event.
          */
-        post(method: "Network.loadNetworkResource", params?: Network.LoadNetworkResourceParameterType): Promise<Network.LoadNetworkResourceReturnType>;
+        post(method: "NodeTracing.stop"): Promise<void>;
         /**
-         * Enable the NodeRuntime events except by `NodeRuntime.waitingForDisconnect`.
+         * Sends protocol message over session with given id.
          */
-        post(method: "NodeRuntime.enable"): Promise<void>;
+        post(method: "NodeWorker.sendMessageToWorker", params?: NodeWorker.SendMessageToWorkerParameterType): Promise<void>;
         /**
-         * Disable NodeRuntime events
+         * Instructs the inspector to attach to running workers. Will also attach to new workers
+         * as they start
          */
-        post(method: "NodeRuntime.disable"): Promise<void>;
+        post(method: "NodeWorker.enable", params?: NodeWorker.EnableParameterType): Promise<void>;
         /**
-         * Enable the `NodeRuntime.waitingForDisconnect`.
+         * Detaches from all running workers and disables attaching to new workers as they are started.
          */
-        post(method: "NodeRuntime.notifyWhenWaitingForDisconnect", params?: NodeRuntime.NotifyWhenWaitingForDisconnectParameterType): Promise<void>;
-        post(method: "Target.setAutoAttach", params?: Target.SetAutoAttachParameterType): Promise<void>;
+        post(method: "NodeWorker.disable"): Promise<void>;
         /**
-         * Read a chunk of the stream
+         * Detached from the worker with given sessionId.
          */
-        post(method: "IO.read", params?: IO.ReadParameterType): Promise<IO.ReadReturnType>;
-        post(method: "IO.close", params?: IO.CloseParameterType): Promise<void>;
+        post(method: "NodeWorker.detach", params?: NodeWorker.DetachParameterType): Promise<void>;
+        post(method: "Target.setAutoAttach", params?: Target.SetAutoAttachParameterType): Promise<void>;
         addListener(event: string, listener: (...args: any[]) => void): this;
         /**
          * Emitted when any notification from the V8 Inspector is received.
@@ -3581,28 +3594,6 @@ declare module "node:inspector/promises" {
          * If heap objects tracking has been started then backend may send update for one or more fragments
          */
         addListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
-        /**
-         * Contains an bucket of collected trace events.
-         */
-        addListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
-        /**
-         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
-         * delivered via dataCollected events.
-         */
-        addListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
-        /**
-         * Issued when attached to a worker.
-         */
-        addListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
-        /**
-         * Issued when detached from the worker.
-         */
-        addListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
-        /**
-         * Notifies about a new protocol message received from the session
-         * (session ID is provided in attachedToWorker notification).
-         */
-        addListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
         /**
          * Fired when page is about to send HTTP request.
          */
@@ -3641,6 +3632,28 @@ declare module "node:inspector/promises" {
          * example, when inspector.waitingForDebugger is called
          */
         addListener(event: "NodeRuntime.waitingForDebugger", listener: () => void): this;
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        addListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        addListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
+        /**
+         * Issued when attached to a worker.
+         */
+        addListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+        /**
+         * Issued when detached from the worker.
+         */
+        addListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        addListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => 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;
@@ -3665,11 +3678,6 @@ declare module "node:inspector/promises" {
         emit(event: "HeapProfiler.reportHeapSnapshotProgress", message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>): boolean;
         emit(event: "HeapProfiler.lastSeenObjectId", message: InspectorNotification<HeapProfiler.LastSeenObjectIdEventDataType>): boolean;
         emit(event: "HeapProfiler.heapStatsUpdate", message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>): boolean;
-        emit(event: "NodeTracing.dataCollected", message: InspectorNotification<NodeTracing.DataCollectedEventDataType>): boolean;
-        emit(event: "NodeTracing.tracingComplete"): boolean;
-        emit(event: "NodeWorker.attachedToWorker", message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>): boolean;
-        emit(event: "NodeWorker.detachedFromWorker", message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>): boolean;
-        emit(event: "NodeWorker.receivedMessageFromWorker", message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>): boolean;
         emit(event: "Network.requestWillBeSent", message: InspectorNotification<Network.RequestWillBeSentEventDataType>): boolean;
         emit(event: "Network.responseReceived", message: InspectorNotification<Network.ResponseReceivedEventDataType>): boolean;
         emit(event: "Network.loadingFailed", message: InspectorNotification<Network.LoadingFailedEventDataType>): boolean;
@@ -3680,6 +3688,11 @@ declare module "node:inspector/promises" {
         emit(event: "Network.webSocketHandshakeResponseReceived", message: InspectorNotification<Network.WebSocketHandshakeResponseReceivedEventDataType>): boolean;
         emit(event: "NodeRuntime.waitingForDisconnect"): boolean;
         emit(event: "NodeRuntime.waitingForDebugger"): boolean;
+        emit(event: "NodeTracing.dataCollected", message: InspectorNotification<NodeTracing.DataCollectedEventDataType>): boolean;
+        emit(event: "NodeTracing.tracingComplete"): boolean;
+        emit(event: "NodeWorker.attachedToWorker", message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>): boolean;
+        emit(event: "NodeWorker.detachedFromWorker", message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>): boolean;
+        emit(event: "NodeWorker.receivedMessageFromWorker", message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>): 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;
@@ -3755,28 +3768,6 @@ declare module "node:inspector/promises" {
          * If heap objects tracking has been started then backend may send update for one or more fragments
          */
         on(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
-        /**
-         * Contains an bucket of collected trace events.
-         */
-        on(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
-        /**
-         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
-         * delivered via dataCollected events.
-         */
-        on(event: "NodeTracing.tracingComplete", listener: () => void): this;
-        /**
-         * Issued when attached to a worker.
-         */
-        on(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
-        /**
-         * Issued when detached from the worker.
-         */
-        on(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
-        /**
-         * Notifies about a new protocol message received from the session
-         * (session ID is provided in attachedToWorker notification).
-         */
-        on(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
         /**
          * Fired when page is about to send HTTP request.
          */
@@ -3815,6 +3806,28 @@ declare module "node:inspector/promises" {
          * example, when inspector.waitingForDebugger is called
          */
         on(event: "NodeRuntime.waitingForDebugger", listener: () => void): this;
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        on(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        on(event: "NodeTracing.tracingComplete", listener: () => void): this;
+        /**
+         * Issued when attached to a worker.
+         */
+        on(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+        /**
+         * Issued when detached from the worker.
+         */
+        on(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        on(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => 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;
@@ -3890,28 +3903,6 @@ declare module "node:inspector/promises" {
          * If heap objects tracking has been started then backend may send update for one or more fragments
          */
         once(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
-        /**
-         * Contains an bucket of collected trace events.
-         */
-        once(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
-        /**
-         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
-         * delivered via dataCollected events.
-         */
-        once(event: "NodeTracing.tracingComplete", listener: () => void): this;
-        /**
-         * Issued when attached to a worker.
-         */
-        once(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
-        /**
-         * Issued when detached from the worker.
-         */
-        once(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
-        /**
-         * Notifies about a new protocol message received from the session
-         * (session ID is provided in attachedToWorker notification).
-         */
-        once(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
         /**
          * Fired when page is about to send HTTP request.
          */
@@ -3950,6 +3941,28 @@ declare module "node:inspector/promises" {
          * example, when inspector.waitingForDebugger is called
          */
         once(event: "NodeRuntime.waitingForDebugger", listener: () => void): this;
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        once(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        once(event: "NodeTracing.tracingComplete", listener: () => void): this;
+        /**
+         * Issued when attached to a worker.
+         */
+        once(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+        /**
+         * Issued when detached from the worker.
+         */
+        once(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        once(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => 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;
@@ -4025,28 +4038,6 @@ declare module "node:inspector/promises" {
          * If heap objects tracking has been started then backend may send update for one or more fragments
          */
         prependListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
-        /**
-         * Contains an bucket of collected trace events.
-         */
-        prependListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
-        /**
-         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
-         * delivered via dataCollected events.
-         */
-        prependListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
-        /**
-         * Issued when attached to a worker.
-         */
-        prependListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
-        /**
-         * Issued when detached from the worker.
-         */
-        prependListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
-        /**
-         * Notifies about a new protocol message received from the session
-         * (session ID is provided in attachedToWorker notification).
-         */
-        prependListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
         /**
          * Fired when page is about to send HTTP request.
          */
@@ -4085,6 +4076,28 @@ declare module "node:inspector/promises" {
          * example, when inspector.waitingForDebugger is called
          */
         prependListener(event: "NodeRuntime.waitingForDebugger", listener: () => void): this;
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        prependListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        prependListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
+        /**
+         * Issued when attached to a worker.
+         */
+        prependListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+        /**
+         * Issued when detached from the worker.
+         */
+        prependListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        prependListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => 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;
@@ -4160,28 +4173,6 @@ declare module "node:inspector/promises" {
          * If heap objects tracking has been started then backend may send update for one or more fragments
          */
         prependOnceListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
-        /**
-         * Contains an bucket of collected trace events.
-         */
-        prependOnceListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
-        /**
-         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
-         * delivered via dataCollected events.
-         */
-        prependOnceListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
-        /**
-         * Issued when attached to a worker.
-         */
-        prependOnceListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
-        /**
-         * Issued when detached from the worker.
-         */
-        prependOnceListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
-        /**
-         * Notifies about a new protocol message received from the session
-         * (session ID is provided in attachedToWorker notification).
-         */
-        prependOnceListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
         /**
          * Fired when page is about to send HTTP request.
          */
@@ -4220,6 +4211,28 @@ declare module "node:inspector/promises" {
          * example, when inspector.waitingForDebugger is called
          */
         prependOnceListener(event: "NodeRuntime.waitingForDebugger", listener: () => void): this;
+        /**
+         * Contains an bucket of collected trace events.
+         */
+        prependOnceListener(event: "NodeTracing.dataCollected", listener: (message: InspectorNotification<NodeTracing.DataCollectedEventDataType>) => void): this;
+        /**
+         * Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+         * delivered via dataCollected events.
+         */
+        prependOnceListener(event: "NodeTracing.tracingComplete", listener: () => void): this;
+        /**
+         * Issued when attached to a worker.
+         */
+        prependOnceListener(event: "NodeWorker.attachedToWorker", listener: (message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>) => void): this;
+        /**
+         * Issued when detached from the worker.
+         */
+        prependOnceListener(event: "NodeWorker.detachedFromWorker", listener: (message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>) => void): this;
+        /**
+         * Notifies about a new protocol message received from the session
+         * (session ID is provided in attachedToWorker notification).
+         */
+        prependOnceListener(event: "NodeWorker.receivedMessageFromWorker", listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
         prependOnceListener(event: "Target.targetCreated", listener: (message: InspectorNotification<Target.TargetCreatedEventDataType>) => void): this;
         prependOnceListener(event: "Target.attachedToTarget", listener: (message: InspectorNotification<Target.AttachedToTargetEventDataType>) => void): this;
     }