cdk-ecr-deployment 3.0.111 → 3.0.113

package/node_modules/@types/responselike/node_modules/@types/node/https.d.ts

@@ -10,7 +10,7 @@ declare module "https" {
     import { URL } from "node:url";
     type ServerOptions<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
-        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+        Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse,
     > = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions<Request, Response>;
     type RequestOptions =
         & http.RequestOptions
@@ -34,7 +34,7 @@ declare module "https" {
     }
     interface Server<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
-        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+        Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse,
     > extends http.Server<Request, Response> {}
     /**
      * See `http.Server` for more information.
@@ -42,7 +42,7 @@ declare module "https" {
      */
     class Server<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
-        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+        Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse,
     > extends tls.Server {
         constructor(requestListener?: http.RequestListener<Request, Response>);
         constructor(
@@ -119,25 +119,19 @@ declare module "https" {
         emit(
             event: "checkContinue",
             req: InstanceType<Request>,
-            res: InstanceType<Response> & {
-                req: InstanceType<Request>;
-            },
+            res: InstanceType<Response>,
         ): boolean;
         emit(
             event: "checkExpectation",
             req: InstanceType<Request>,
-            res: InstanceType<Response> & {
-                req: InstanceType<Request>;
-            },
+            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: "request",
             req: InstanceType<Request>,
-            res: InstanceType<Response> & {
-                req: InstanceType<Request>;
-            },
+            res: InstanceType<Response>,
         ): boolean;
         emit(event: "upgrade", req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
@@ -276,8 +270,8 @@ declare module "https" {
     /**
      * ```js
      * // curl -k https://localhost:8000/
-     * const https = require('node:https');
-     * const fs = require('node:fs');
+     * import https from 'node:https';
+     * import fs from 'node:fs';
      *
      * const options = {
      *   key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
@@ -293,8 +287,8 @@ declare module "https" {
      * Or
      *
      * ```js
-     * const https = require('node:https');
-     * const fs = require('node:fs');
+     * import https from 'node:https';
+     * import fs from 'node:fs';
      *
      * const options = {
      *   pfx: fs.readFileSync('test/fixtures/test_cert.pfx'),
@@ -312,11 +306,11 @@ declare module "https" {
      */
     function createServer<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
-        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+        Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse,
     >(requestListener?: http.RequestListener<Request, Response>): Server<Request, Response>;
     function createServer<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
-        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+        Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse,
     >(
         options: ServerOptions<Request, Response>,
         requestListener?: http.RequestListener<Request, Response>,
@@ -334,7 +328,7 @@ declare module "https" {
      * upload a file with a POST request, then write to the `ClientRequest` object.
      *
      * ```js
-     * const https = require('node:https');
+     * import https from 'node:https';
      *
      * const options = {
      *   hostname: 'encrypted.google.com',
@@ -407,9 +401,9 @@ declare module "https" {
      * Example pinning on certificate fingerprint, or the public key (similar to`pin-sha256`):
      *
      * ```js
-     * const tls = require('node:tls');
-     * const https = require('node:https');
-     * const crypto = require('node:crypto');
+     * import tls from 'node:tls';
+     * import https from 'node:https';
+     * import crypto from 'node:crypto';
      *
      * function sha256(s) {
      *   return crypto.createHash('sha256').update(s).digest('base64');
@@ -517,7 +511,7 @@ declare module "https" {
      * string, it is automatically parsed with `new URL()`. If it is a `URL` object, it will be automatically converted to an ordinary `options` object.
      *
      * ```js
-     * const https = require('node:https');
+     * import https from 'node:https';
      *
      * https.get('https://encrypted.google.com/', (res) => {
      *   console.log('statusCode:', res.statusCode);

package/node_modules/@types/responselike/node_modules/@types/node/index.d.ts

@@ -22,7 +22,7 @@
  * IN THE SOFTWARE.
  */
 
-// NOTE: These definitions support NodeJS and TypeScript 4.9+.
+// NOTE: These definitions support NodeJS and TypeScript 5.7+.
 
 // Reference required types from the default lib:
 /// <reference lib="es2020" />
@@ -30,6 +30,10 @@
 /// <reference lib="esnext.intl" />
 /// <reference lib="esnext.bigint" />
 
+// Definitions specific to TypeScript 4.9 through 5.7+
+/// <reference path="globals.typedarray.d.ts" />
+/// <reference path="buffer.buffer.d.ts" />
+
 // Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
 /// <reference path="assert.d.ts" />
 /// <reference path="assert/strict.d.ts" />

package/node_modules/@types/responselike/node_modules/@types/node/inspector.d.ts

@@ -1703,6 +1703,110 @@ declare module 'inspector' {
             message: string;
         }
     }
+    namespace Network {
+        /**
+         * Resource type as it was perceived by the rendering engine.
+         */
+        type ResourceType = string;
+        /**
+         * Unique request identifier.
+         */
+        type RequestId = string;
+        /**
+         * UTC time in seconds, counted from January 1, 1970.
+         */
+        type TimeSinceEpoch = number;
+        /**
+         * Monotonically increasing time in seconds since an arbitrary point in the past.
+         */
+        type MonotonicTime = number;
+        /**
+         * HTTP request data.
+         */
+        interface Request {
+            url: string;
+            method: string;
+            headers: Headers;
+        }
+        /**
+         * HTTP response data.
+         */
+        interface Response {
+            url: string;
+            status: number;
+            statusText: string;
+            headers: Headers;
+        }
+        /**
+         * Request / response headers as keys / values of JSON object.
+         */
+        interface Headers {
+        }
+        interface RequestWillBeSentEventDataType {
+            /**
+             * Request identifier.
+             */
+            requestId: RequestId;
+            /**
+             * Request data.
+             */
+            request: Request;
+            /**
+             * Timestamp.
+             */
+            timestamp: MonotonicTime;
+            /**
+             * Timestamp.
+             */
+            wallTime: TimeSinceEpoch;
+        }
+        interface ResponseReceivedEventDataType {
+            /**
+             * Request identifier.
+             */
+            requestId: RequestId;
+            /**
+             * Timestamp.
+             */
+            timestamp: MonotonicTime;
+            /**
+             * Resource type.
+             */
+            type: ResourceType;
+            /**
+             * Response data.
+             */
+            response: Response;
+        }
+        interface LoadingFailedEventDataType {
+            /**
+             * Request identifier.
+             */
+            requestId: RequestId;
+            /**
+             * Timestamp.
+             */
+            timestamp: MonotonicTime;
+            /**
+             * Resource type.
+             */
+            type: ResourceType;
+            /**
+             * Error message.
+             */
+            errorText: string;
+        }
+        interface LoadingFinishedEventDataType {
+            /**
+             * Request identifier.
+             */
+            requestId: RequestId;
+            /**
+             * Timestamp.
+             */
+            timestamp: MonotonicTime;
+        }
+    }
     namespace NodeRuntime {
         interface NotifyWhenWaitingForDisconnectParameterType {
             enabled: boolean;
@@ -2076,6 +2180,14 @@ declare module 'inspector' {
          */
         post(method: 'NodeWorker.detach', params?: NodeWorker.DetachParameterType, callback?: (err: Error | null) => void): void;
         post(method: 'NodeWorker.detach', callback?: (err: Error | null) => void): void;
+        /**
+         * Disables network tracking, prevents network events from being sent to the client.
+         */
+        post(method: 'Network.disable', callback?: (err: Error | null) => void): void;
+        /**
+         * Enables network tracking, network events will now be delivered to the client.
+         */
+        post(method: 'Network.enable', callback?: (err: Error | null) => void): void;
         /**
          * Enable the NodeRuntime events except by `NodeRuntime.waitingForDisconnect`.
          */
@@ -2185,6 +2297,16 @@ declare module 'inspector' {
          * (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.
+         */
+        addListener(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        addListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        addListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        addListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2224,6 +2346,10 @@ declare module 'inspector' {
         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;
+        emit(event: 'Network.loadingFinished', message: InspectorNotification<Network.LoadingFinishedEventDataType>): boolean;
         emit(event: 'NodeRuntime.waitingForDisconnect'): boolean;
         emit(event: 'NodeRuntime.waitingForDebugger'): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
@@ -2321,6 +2447,16 @@ declare module 'inspector' {
          * (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.
+         */
+        on(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        on(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        on(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        on(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2428,6 +2564,16 @@ declare module 'inspector' {
          * (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.
+         */
+        once(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        once(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        once(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        once(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2535,6 +2681,16 @@ declare module 'inspector' {
          * (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.
+         */
+        prependListener(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        prependListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        prependListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        prependListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2642,6 +2798,16 @@ declare module 'inspector' {
          * (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.
+         */
+        prependOnceListener(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        prependOnceListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        prependOnceListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        prependOnceListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2737,6 +2903,46 @@ declare module 'inspector' {
      * @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
+         * @experimental
+         */
+        function requestWillBeSent(params: RequestWillBeSentEventDataType): 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
+         * @experimental
+         */
+        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
+         * @experimental
+         */
+        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
+         * @experimental
+         */
+        function loadingFailed(params: LoadingFailedEventDataType): void;
+    }
 }
 
 /**
@@ -2770,6 +2976,7 @@ declare module 'inspector/promises' {
         HeapProfiler,
         NodeTracing,
         NodeWorker,
+        Network,
         NodeRuntime,
     } from 'inspector';
 
@@ -3087,6 +3294,14 @@ declare module 'inspector/promises' {
          * Detached from the worker with given sessionId.
          */
         post(method: 'NodeWorker.detach', params?: NodeWorker.DetachParameterType): Promise<void>;
+        /**
+         * Disables network tracking, prevents network events from being sent to the client.
+         */
+        post(method: 'Network.disable'): Promise<void>;
+        /**
+         * Enables network tracking, network events will now be delivered to the client.
+         */
+        post(method: 'Network.enable'): Promise<void>;
         /**
          * Enable the NodeRuntime events except by `NodeRuntime.waitingForDisconnect`.
          */
@@ -3195,6 +3410,16 @@ declare module 'inspector/promises' {
          * (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.
+         */
+        addListener(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        addListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        addListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        addListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3234,6 +3459,10 @@ declare module 'inspector/promises' {
         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;
+        emit(event: 'Network.loadingFinished', message: InspectorNotification<Network.LoadingFinishedEventDataType>): boolean;
         emit(event: 'NodeRuntime.waitingForDisconnect'): boolean;
         emit(event: 'NodeRuntime.waitingForDebugger'): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
@@ -3331,6 +3560,16 @@ declare module 'inspector/promises' {
          * (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.
+         */
+        on(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        on(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        on(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        on(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3438,6 +3677,16 @@ declare module 'inspector/promises' {
          * (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.
+         */
+        once(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        once(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        once(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        once(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3545,6 +3794,16 @@ declare module 'inspector/promises' {
          * (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.
+         */
+        prependListener(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        prependListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        prependListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        prependListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3652,6 +3911,16 @@ declare module 'inspector/promises' {
          * (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.
+         */
+        prependOnceListener(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        prependOnceListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        prependOnceListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        prependOnceListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3682,6 +3951,7 @@ declare module 'inspector/promises' {
         HeapProfiler,
         NodeTracing,
         NodeWorker,
+        Network,
         NodeRuntime,
     };
 }

package/node_modules/@types/responselike/node_modules/@types/node/module.d.ts

@@ -12,9 +12,9 @@ declare module "module" {
          * does not add or remove exported names from the `ES Modules`.
          *
          * ```js
-         * const fs = require('node:fs');
-         * const assert = require('node:assert');
-         * const { syncBuiltinESMExports } = require('node:module');
+         * import fs from 'node:fs';
+         * import assert from 'node:assert';
+         * import { syncBuiltinESMExports } from 'node:module';
          *
          * fs.readFile = newAPI;
          *

package/node_modules/@types/responselike/node_modules/@types/node/net.d.ts

@@ -8,7 +8,7 @@
  * It can be accessed using:
  *
  * ```js
- * const net = require('node:net');
+ * import net from 'node:net';
  * ```
  * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/net.js)
  */
@@ -29,6 +29,7 @@ declare module "net" {
     interface SocketConstructorOpts {
         fd?: number | undefined;
         allowHalfOpen?: boolean | undefined;
+        onread?: OnReadOpts | undefined;
         readable?: boolean | undefined;
         writable?: boolean | undefined;
         signal?: AbortSignal;
@@ -37,20 +38,15 @@ declare module "net" {
         buffer: Uint8Array | (() => Uint8Array);
         /**
          * This function is called for every chunk of incoming data.
-         * Two arguments are passed to it: the number of bytes written to buffer and a reference to buffer.
-         * Return false from this function to implicitly pause() the socket.
+         * Two arguments are passed to it: the number of bytes written to `buffer` and a reference to `buffer`.
+         * Return `false` from this function to implicitly `pause()` the socket.
          */
-        callback(bytesWritten: number, buf: Uint8Array): boolean;
-    }
-    interface ConnectOpts {
-        /**
-         * If specified, incoming data is stored in a single buffer and passed to the supplied callback when data arrives on the socket.
-         * Note: this will cause the streaming functionality to not provide any data, however events like 'error', 'end', and 'close' will
-         * still be emitted as normal and methods like pause() and resume() will also behave as expected.
-         */
-        onread?: OnReadOpts | undefined;
+        callback(bytesWritten: number, buffer: Uint8Array): boolean;
     }
-    interface TcpSocketConnectOpts extends ConnectOpts {
+    // TODO: remove empty ConnectOpts placeholder at next major @types/node version.
+    /** @deprecated */
+    interface ConnectOpts {}
+    interface TcpSocketConnectOpts {
         port: number;
         host?: string | undefined;
         localAddress?: string | undefined;
@@ -70,7 +66,7 @@ declare module "net" {
          */
         autoSelectFamilyAttemptTimeout?: number | undefined;
     }
-    interface IpcSocketConnectOpts extends ConnectOpts {
+    interface IpcSocketConnectOpts {
         path: string;
     }
     type SocketConnectOpts = TcpSocketConnectOpts | IpcSocketConnectOpts;
@@ -812,7 +808,7 @@ declare module "net" {
      * on port 8124:
      *
      * ```js
-     * const net = require('node:net');
+     * import net from 'node:net';
      * const server = net.createServer((c) => {
      *   // 'connection' listener.
      *   console.log('client connected');

package/node_modules/@types/responselike/node_modules/@types/node/os.d.ts

@@ -3,7 +3,7 @@
  * properties. It can be accessed using:
  *
  * ```js
- * const os = require('node:os');
+ * import os from 'node:os';
  * ```
  * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/os.js)
  */

package/node_modules/@types/responselike/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "22.5.5",
+    "version": "22.7.4",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -203,6 +203,13 @@
     ],
     "main": "",
     "types": "index.d.ts",
+    "typesVersions": {
+        "<=5.6": {
+            "*": [
+                "ts5.6/*"
+            ]
+        }
+    },
     "repository": {
         "type": "git",
         "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
@@ -212,6 +219,6 @@
     "dependencies": {
         "undici-types": "~6.19.2"
     },
-    "typesPublisherContentHash": "49c6854801c6eca5f0c4debaa90673195b7385ea09dc082e76a86be2fa20430f",
+    "typesPublisherContentHash": "58c8a4b0f59c44e08d89b33eab493f0e44c78851904ecec99425a6357184e01b",
     "typeScriptVersion": "4.8"
 }

package/node_modules/@types/responselike/node_modules/@types/node/path.d.ts

@@ -11,7 +11,7 @@ declare module "path/win32" {
  * paths. It can be accessed using:
  *
  * ```js
- * const path = require('node:path');
+ * import path from 'node:path';
  * ```
  * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/path.js)
  */