devtools-protocol 0.0.1446921 → 0.0.1448144

package/json/browser_protocol.json

@@ -16330,6 +16330,63 @@
                         }
                     ]
                 },
+                {
+                    "name": "directTCPSocketChunkSent",
+                    "description": "Fired when data is sent to tcp direct socket stream.",
+                    "experimental": true,
+                    "parameters": [
+                        {
+                            "name": "identifier",
+                            "$ref": "RequestId"
+                        },
+                        {
+                            "name": "data",
+                            "type": "string"
+                        },
+                        {
+                            "name": "timestamp",
+                            "$ref": "MonotonicTime"
+                        }
+                    ]
+                },
+                {
+                    "name": "directTCPSocketChunkReceived",
+                    "description": "Fired when data is received from tcp direct socket stream.",
+                    "experimental": true,
+                    "parameters": [
+                        {
+                            "name": "identifier",
+                            "$ref": "RequestId"
+                        },
+                        {
+                            "name": "data",
+                            "type": "string"
+                        },
+                        {
+                            "name": "timestamp",
+                            "$ref": "MonotonicTime"
+                        }
+                    ]
+                },
+                {
+                    "name": "directTCPSocketChunkError",
+                    "description": "Fired when there is an error\nwhen writing to tcp direct socket stream.\nFor example, if user writes illegal type like string\ninstead of ArrayBuffer or ArrayBufferView.\nThere's no reporting for reading, because\nwe cannot know errors on the other side.",
+                    "experimental": true,
+                    "parameters": [
+                        {
+                            "name": "identifier",
+                            "$ref": "RequestId"
+                        },
+                        {
+                            "name": "errorMessage",
+                            "type": "string"
+                        },
+                        {
+                            "name": "timestamp",
+                            "$ref": "MonotonicTime"
+                        }
+                    ]
+                },
                 {
                     "name": "requestWillBeSentExtraInfo",
                     "description": "Fired when additional information about a requestWillBeSent event is available from the\nnetwork stack. Not every requestWillBeSent event will have an additional\nrequestWillBeSentExtraInfo fired for it, and there is no guarantee whether requestWillBeSent\nor requestWillBeSentExtraInfo will be fired first for the same request.",
@@ -23706,6 +23763,26 @@
                             }
                         }
                     ]
+                },
+                {
+                    "name": "setProtectedAudienceKAnonymity",
+                    "parameters": [
+                        {
+                            "name": "owner",
+                            "type": "string"
+                        },
+                        {
+                            "name": "name",
+                            "type": "string"
+                        },
+                        {
+                            "name": "hashes",
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        }
+                    ]
                 }
             ],
             "events": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devtools-protocol",
-  "version": "0.0.1446921",
+  "version": "0.0.1448144",
   "description": "The Chrome DevTools Protocol JSON",
   "repository": "https://github.com/ChromeDevTools/devtools-protocol",
   "author": "The Chromium Authors",

package/pdl/browser_protocol.pdl

@@ -7512,6 +7512,32 @@ domain Network
       RequestId identifier
       MonotonicTime timestamp
 
+  # Fired when data is sent to tcp direct socket stream.
+  experimental event directTCPSocketChunkSent
+    parameters
+      RequestId identifier
+      binary data
+      MonotonicTime timestamp
+
+  # Fired when data is received from tcp direct socket stream.
+  experimental event directTCPSocketChunkReceived
+    parameters
+      RequestId identifier
+      binary data
+      MonotonicTime timestamp
+
+  # Fired when there is an error
+  # when writing to tcp direct socket stream.
+  # For example, if user writes illegal type like string
+  # instead of ArrayBuffer or ArrayBufferView.
+  # There's no reporting for reading, because
+  # we cannot know errors on the other side.
+  experimental event directTCPSocketChunkError
+    parameters
+      RequestId identifier
+      string errorMessage
+      MonotonicTime timestamp
+
   experimental type PrivateNetworkRequestPolicy extends string
     enum
       Allow
@@ -11307,6 +11333,12 @@ experimental domain Storage
       # party URL, only the first-party URL is returned in the array.
       array of string matchedUrls
 
+  command setProtectedAudienceKAnonymity
+    parameters
+      string owner
+      string name
+      array of binary hashes
+
 # The SystemInfo domain defines methods and events for querying low-level system information.
 experimental domain SystemInfo
 

package/types/protocol-mapping.d.ts

@@ -367,6 +367,23 @@ export namespace ProtocolMapping {
          * Fired when direct_socket.TCPSocket is closed.
          */
         'Network.directTCPSocketClosed': [Protocol.Network.DirectTCPSocketClosedEvent];
+        /**
+         * Fired when data is sent to tcp direct socket stream.
+         */
+        'Network.directTCPSocketChunkSent': [Protocol.Network.DirectTCPSocketChunkSentEvent];
+        /**
+         * Fired when data is received from tcp direct socket stream.
+         */
+        'Network.directTCPSocketChunkReceived': [Protocol.Network.DirectTCPSocketChunkReceivedEvent];
+        /**
+         * Fired when there is an error
+         * when writing to tcp direct socket stream.
+         * For example, if user writes illegal type like string
+         * instead of ArrayBuffer or ArrayBufferView.
+         * There's no reporting for reading, because
+         * we cannot know errors on the other side.
+         */
+        'Network.directTCPSocketChunkError': [Protocol.Network.DirectTCPSocketChunkErrorEvent];
         /**
          * Fired when additional information about a requestWillBeSent event is available from the
          * network stack. Not every requestWillBeSent event will have an additional
@@ -4695,6 +4712,10 @@ export namespace ProtocolMapping {
             paramsType: [Protocol.Storage.GetAffectedUrlsForThirdPartyCookieMetadataRequest];
             returnType: Protocol.Storage.GetAffectedUrlsForThirdPartyCookieMetadataResponse;
         };
+        'Storage.setProtectedAudienceKAnonymity': {
+            paramsType: [Protocol.Storage.SetProtectedAudienceKAnonymityRequest];
+            returnType: void;
+        };
         /**
          * Returns information about the system.
          */

package/types/protocol-proxy-api.d.ts

@@ -2731,6 +2731,26 @@ export namespace ProtocolProxyApi {
          */
         on(event: 'directTCPSocketClosed', listener: (params: Protocol.Network.DirectTCPSocketClosedEvent) => void): void;
 
+        /**
+         * Fired when data is sent to tcp direct socket stream.
+         */
+        on(event: 'directTCPSocketChunkSent', listener: (params: Protocol.Network.DirectTCPSocketChunkSentEvent) => void): void;
+
+        /**
+         * Fired when data is received from tcp direct socket stream.
+         */
+        on(event: 'directTCPSocketChunkReceived', listener: (params: Protocol.Network.DirectTCPSocketChunkReceivedEvent) => void): void;
+
+        /**
+         * Fired when there is an error
+         * when writing to tcp direct socket stream.
+         * For example, if user writes illegal type like string
+         * instead of ArrayBuffer or ArrayBufferView.
+         * There's no reporting for reading, because
+         * we cannot know errors on the other side.
+         */
+        on(event: 'directTCPSocketChunkError', listener: (params: Protocol.Network.DirectTCPSocketChunkErrorEvent) => void): void;
+
         /**
          * Fired when additional information about a requestWillBeSent event is available from the
          * network stack. Not every requestWillBeSent event will have an additional
@@ -3750,6 +3770,8 @@ export namespace ProtocolProxyApi {
          */
         getAffectedUrlsForThirdPartyCookieMetadata(params: Protocol.Storage.GetAffectedUrlsForThirdPartyCookieMetadataRequest): Promise<Protocol.Storage.GetAffectedUrlsForThirdPartyCookieMetadataResponse>;
 
+        setProtectedAudienceKAnonymity(params: Protocol.Storage.SetProtectedAudienceKAnonymityRequest): Promise<void>;
+
         /**
          * A cache's contents have been modified.
          */

package/types/protocol-tests-proxy-api.d.ts

@@ -2919,6 +2919,32 @@ export namespace ProtocolTestsProxyApi {
         offDirectTCPSocketClosed(listener: (event: { params: Protocol.Network.DirectTCPSocketClosedEvent }) => void): void;
         onceDirectTCPSocketClosed(eventMatcher?: (event: { params: Protocol.Network.DirectTCPSocketClosedEvent }) => boolean): Promise<{ params: Protocol.Network.DirectTCPSocketClosedEvent }>;
 
+        /**
+         * Fired when data is sent to tcp direct socket stream.
+         */
+        onDirectTCPSocketChunkSent(listener: (event: { params: Protocol.Network.DirectTCPSocketChunkSentEvent }) => void): void;
+        offDirectTCPSocketChunkSent(listener: (event: { params: Protocol.Network.DirectTCPSocketChunkSentEvent }) => void): void;
+        onceDirectTCPSocketChunkSent(eventMatcher?: (event: { params: Protocol.Network.DirectTCPSocketChunkSentEvent }) => boolean): Promise<{ params: Protocol.Network.DirectTCPSocketChunkSentEvent }>;
+
+        /**
+         * Fired when data is received from tcp direct socket stream.
+         */
+        onDirectTCPSocketChunkReceived(listener: (event: { params: Protocol.Network.DirectTCPSocketChunkReceivedEvent }) => void): void;
+        offDirectTCPSocketChunkReceived(listener: (event: { params: Protocol.Network.DirectTCPSocketChunkReceivedEvent }) => void): void;
+        onceDirectTCPSocketChunkReceived(eventMatcher?: (event: { params: Protocol.Network.DirectTCPSocketChunkReceivedEvent }) => boolean): Promise<{ params: Protocol.Network.DirectTCPSocketChunkReceivedEvent }>;
+
+        /**
+         * Fired when there is an error
+         * when writing to tcp direct socket stream.
+         * For example, if user writes illegal type like string
+         * instead of ArrayBuffer or ArrayBufferView.
+         * There's no reporting for reading, because
+         * we cannot know errors on the other side.
+         */
+        onDirectTCPSocketChunkError(listener: (event: { params: Protocol.Network.DirectTCPSocketChunkErrorEvent }) => void): void;
+        offDirectTCPSocketChunkError(listener: (event: { params: Protocol.Network.DirectTCPSocketChunkErrorEvent }) => void): void;
+        onceDirectTCPSocketChunkError(eventMatcher?: (event: { params: Protocol.Network.DirectTCPSocketChunkErrorEvent }) => boolean): Promise<{ params: Protocol.Network.DirectTCPSocketChunkErrorEvent }>;
+
         /**
          * Fired when additional information about a requestWillBeSent event is available from the
          * network stack. Not every requestWillBeSent event will have an additional
@@ -4042,6 +4068,8 @@ export namespace ProtocolTestsProxyApi {
          */
         getAffectedUrlsForThirdPartyCookieMetadata(params: Protocol.Storage.GetAffectedUrlsForThirdPartyCookieMetadataRequest): Promise<{id: number, result: Protocol.Storage.GetAffectedUrlsForThirdPartyCookieMetadataResponse, sessionId: string}>;
 
+        setProtectedAudienceKAnonymity(params: Protocol.Storage.SetProtectedAudienceKAnonymityRequest): Promise<{id: number, result: void, sessionId: string}>;
+
         /**
          * A cache's contents have been modified.
          */

package/types/protocol.d.ts

@@ -12819,6 +12819,38 @@ export namespace Protocol {
             timestamp: MonotonicTime;
         }
 
+        /**
+         * Fired when data is sent to tcp direct socket stream.
+         */
+        export interface DirectTCPSocketChunkSentEvent {
+            identifier: RequestId;
+            data: string;
+            timestamp: MonotonicTime;
+        }
+
+        /**
+         * Fired when data is received from tcp direct socket stream.
+         */
+        export interface DirectTCPSocketChunkReceivedEvent {
+            identifier: RequestId;
+            data: string;
+            timestamp: MonotonicTime;
+        }
+
+        /**
+         * Fired when there is an error
+         * when writing to tcp direct socket stream.
+         * For example, if user writes illegal type like string
+         * instead of ArrayBuffer or ArrayBufferView.
+         * There's no reporting for reading, because
+         * we cannot know errors on the other side.
+         */
+        export interface DirectTCPSocketChunkErrorEvent {
+            identifier: RequestId;
+            errorMessage: string;
+            timestamp: MonotonicTime;
+        }
+
         /**
          * Fired when additional information about a requestWillBeSent event is available from the
          * network stack. Not every requestWillBeSent event will have an additional
@@ -17005,6 +17037,12 @@ export namespace Protocol {
             matchedUrls: string[];
         }
 
+        export interface SetProtectedAudienceKAnonymityRequest {
+            owner: string;
+            name: string;
+            hashes: string[];
+        }
+
         /**
          * A cache's contents have been modified.
          */