devtools-protocol 0.0.1498010 → 0.0.1501221

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

@@ -28,12 +28,12 @@ export namespace ProtocolTestsProxyApi {
 
         Audits: AuditsApi;
 
-        Extensions: ExtensionsApi;
-
         Autofill: AutofillApi;
 
         BackgroundService: BackgroundServiceApi;
 
+        BluetoothEmulation: BluetoothEmulationApi;
+
         Browser: BrowserApi;
 
         CSS: CSSApi;
@@ -46,22 +46,30 @@ export namespace ProtocolTestsProxyApi {
 
         DOMDebugger: DOMDebuggerApi;
 
-        EventBreakpoints: EventBreakpointsApi;
-
         DOMSnapshot: DOMSnapshotApi;
 
         DOMStorage: DOMStorageApi;
 
+        DeviceAccess: DeviceAccessApi;
+
         DeviceOrientation: DeviceOrientationApi;
 
         Emulation: EmulationApi;
 
-        HeadlessExperimental: HeadlessExperimentalApi;
+        EventBreakpoints: EventBreakpointsApi;
 
-        IO: IOApi;
+        Extensions: ExtensionsApi;
+
+        FedCm: FedCmApi;
+
+        Fetch: FetchApi;
 
         FileSystem: FileSystemApi;
 
+        HeadlessExperimental: HeadlessExperimentalApi;
+
+        IO: IOApi;
+
         IndexedDB: IndexedDBApi;
 
         Input: InputApi;
@@ -72,18 +80,24 @@ export namespace ProtocolTestsProxyApi {
 
         Log: LogApi;
 
+        Media: MediaApi;
+
         Memory: MemoryApi;
 
         Network: NetworkApi;
 
         Overlay: OverlayApi;
 
+        PWA: PWAApi;
+
         Page: PageApi;
 
         Performance: PerformanceApi;
 
         PerformanceTimeline: PerformanceTimelineApi;
 
+        Preload: PreloadApi;
+
         Security: SecurityApi;
 
         ServiceWorker: ServiceWorkerApi;
@@ -98,24 +112,10 @@ export namespace ProtocolTestsProxyApi {
 
         Tracing: TracingApi;
 
-        Fetch: FetchApi;
-
         WebAudio: WebAudioApi;
 
         WebAuthn: WebAuthnApi;
 
-        Media: MediaApi;
-
-        DeviceAccess: DeviceAccessApi;
-
-        Preload: PreloadApi;
-
-        FedCm: FedCmApi;
-
-        PWA: PWAApi;
-
-        BluetoothEmulation: BluetoothEmulationApi;
-
     }
 
 
@@ -911,47 +911,6 @@ export namespace ProtocolTestsProxyApi {
 
     }
 
-    export interface ExtensionsApi {
-        /**
-         * Installs an unpacked extension from the filesystem similar to
-         * --load-extension CLI flags. Returns extension ID once the extension
-         * has been installed. Available if the client is connected using the
-         * --remote-debugging-pipe flag and the --enable-unsafe-extension-debugging
-         * flag is set.
-         */
-        loadUnpacked(params: Protocol.Extensions.LoadUnpackedRequest): Promise<{id: number, result: Protocol.Extensions.LoadUnpackedResponse, sessionId: string}>;
-
-        /**
-         * Uninstalls an unpacked extension (others not supported) from the profile.
-         * Available if the client is connected using the --remote-debugging-pipe flag
-         * and the --enable-unsafe-extension-debugging.
-         */
-        uninstall(params: Protocol.Extensions.UninstallRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Gets data from extension storage in the given `storageArea`. If `keys` is
-         * specified, these are used to filter the result.
-         */
-        getStorageItems(params: Protocol.Extensions.GetStorageItemsRequest): Promise<{id: number, result: Protocol.Extensions.GetStorageItemsResponse, sessionId: string}>;
-
-        /**
-         * Removes `keys` from extension storage in the given `storageArea`.
-         */
-        removeStorageItems(params: Protocol.Extensions.RemoveStorageItemsRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Clears extension storage in the given `storageArea`.
-         */
-        clearStorageItems(params: Protocol.Extensions.ClearStorageItemsRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Sets `values` in extension storage in the given `storageArea`. The provided `values`
-         * will be merged with existing values in the storage area.
-         */
-        setStorageItems(params: Protocol.Extensions.SetStorageItemsRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-    }
-
     export interface AutofillApi {
         /**
          * Trigger autofill on a form identified by the fieldId.
@@ -1021,6 +980,125 @@ export namespace ProtocolTestsProxyApi {
 
     }
 
+    export interface BluetoothEmulationApi {
+        /**
+         * Enable the BluetoothEmulation domain.
+         */
+        enable(params: Protocol.BluetoothEmulation.EnableRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Set the state of the simulated central.
+         */
+        setSimulatedCentralState(params: Protocol.BluetoothEmulation.SetSimulatedCentralStateRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Disable the BluetoothEmulation domain.
+         */
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Simulates a peripheral with |address|, |name| and |knownServiceUuids|
+         * that has already been connected to the system.
+         */
+        simulatePreconnectedPeripheral(params: Protocol.BluetoothEmulation.SimulatePreconnectedPeripheralRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Simulates an advertisement packet described in |entry| being received by
+         * the central.
+         */
+        simulateAdvertisement(params: Protocol.BluetoothEmulation.SimulateAdvertisementRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Simulates the response code from the peripheral with |address| for a
+         * GATT operation of |type|. The |code| value follows the HCI Error Codes from
+         * Bluetooth Core Specification Vol 2 Part D 1.3 List Of Error Codes.
+         */
+        simulateGATTOperationResponse(params: Protocol.BluetoothEmulation.SimulateGATTOperationResponseRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Simulates the response from the characteristic with |characteristicId| for a
+         * characteristic operation of |type|. The |code| value follows the Error
+         * Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.
+         * The |data| is expected to exist when simulating a successful read operation
+         * response.
+         */
+        simulateCharacteristicOperationResponse(params: Protocol.BluetoothEmulation.SimulateCharacteristicOperationResponseRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Simulates the response from the descriptor with |descriptorId| for a
+         * descriptor operation of |type|. The |code| value follows the Error
+         * Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.
+         * The |data| is expected to exist when simulating a successful read operation
+         * response.
+         */
+        simulateDescriptorOperationResponse(params: Protocol.BluetoothEmulation.SimulateDescriptorOperationResponseRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Adds a service with |serviceUuid| to the peripheral with |address|.
+         */
+        addService(params: Protocol.BluetoothEmulation.AddServiceRequest): Promise<{id: number, result: Protocol.BluetoothEmulation.AddServiceResponse, sessionId: string}>;
+
+        /**
+         * Removes the service respresented by |serviceId| from the simulated central.
+         */
+        removeService(params: Protocol.BluetoothEmulation.RemoveServiceRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Adds a characteristic with |characteristicUuid| and |properties| to the
+         * service represented by |serviceId|.
+         */
+        addCharacteristic(params: Protocol.BluetoothEmulation.AddCharacteristicRequest): Promise<{id: number, result: Protocol.BluetoothEmulation.AddCharacteristicResponse, sessionId: string}>;
+
+        /**
+         * Removes the characteristic respresented by |characteristicId| from the
+         * simulated central.
+         */
+        removeCharacteristic(params: Protocol.BluetoothEmulation.RemoveCharacteristicRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Adds a descriptor with |descriptorUuid| to the characteristic respresented
+         * by |characteristicId|.
+         */
+        addDescriptor(params: Protocol.BluetoothEmulation.AddDescriptorRequest): Promise<{id: number, result: Protocol.BluetoothEmulation.AddDescriptorResponse, sessionId: string}>;
+
+        /**
+         * Removes the descriptor with |descriptorId| from the simulated central.
+         */
+        removeDescriptor(params: Protocol.BluetoothEmulation.RemoveDescriptorRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Simulates a GATT disconnection from the peripheral with |address|.
+         */
+        simulateGATTDisconnection(params: Protocol.BluetoothEmulation.SimulateGATTDisconnectionRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Event for when a GATT operation of |type| to the peripheral with |address|
+         * happened.
+         */
+        onGattOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.GattOperationReceivedEvent }) => void): void;
+        offGattOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.GattOperationReceivedEvent }) => void): void;
+        onceGattOperationReceived(eventMatcher?: (event: { params: Protocol.BluetoothEmulation.GattOperationReceivedEvent }) => boolean): Promise<{ params: Protocol.BluetoothEmulation.GattOperationReceivedEvent }>;
+
+        /**
+         * Event for when a characteristic operation of |type| to the characteristic
+         * respresented by |characteristicId| happened. |data| and |writeType| is
+         * expected to exist when |type| is write.
+         */
+        onCharacteristicOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.CharacteristicOperationReceivedEvent }) => void): void;
+        offCharacteristicOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.CharacteristicOperationReceivedEvent }) => void): void;
+        onceCharacteristicOperationReceived(eventMatcher?: (event: { params: Protocol.BluetoothEmulation.CharacteristicOperationReceivedEvent }) => boolean): Promise<{ params: Protocol.BluetoothEmulation.CharacteristicOperationReceivedEvent }>;
+
+        /**
+         * Event for when a descriptor operation of |type| to the descriptor
+         * respresented by |descriptorId| happened. |data| is expected to exist when
+         * |type| is write.
+         */
+        onDescriptorOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent }) => void): void;
+        offDescriptorOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent }) => void): void;
+        onceDescriptorOperationReceived(eventMatcher?: (event: { params: Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent }) => boolean): Promise<{ params: Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent }>;
+
+    }
+
     export interface BrowserApi {
         /**
          * Set permission settings for given origin.
@@ -2015,24 +2093,6 @@ export namespace ProtocolTestsProxyApi {
 
     }
 
-    export interface EventBreakpointsApi {
-        /**
-         * Sets breakpoint on particular native event.
-         */
-        setInstrumentationBreakpoint(params: Protocol.EventBreakpoints.SetInstrumentationBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Removes breakpoint on particular native event.
-         */
-        removeInstrumentationBreakpoint(params: Protocol.EventBreakpoints.RemoveInstrumentationBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Removes all breakpoints
-         */
-        disable(): Promise<{id: number, result: void, sessionId: string}>;
-
-    }
-
     export interface DOMSnapshotApi {
         /**
          * Disables DOM snapshot agent for the given page.
@@ -2100,6 +2160,37 @@ export namespace ProtocolTestsProxyApi {
 
     }
 
+    export interface DeviceAccessApi {
+        /**
+         * Enable events in this domain.
+         */
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Disable events in this domain.
+         */
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Select a device in response to a DeviceAccess.deviceRequestPrompted event.
+         */
+        selectPrompt(params: Protocol.DeviceAccess.SelectPromptRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Cancel a prompt in response to a DeviceAccess.deviceRequestPrompted event.
+         */
+        cancelPrompt(params: Protocol.DeviceAccess.CancelPromptRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * A device request opened a user prompt to select a device. Respond with the
+         * selectPrompt or cancelPrompt command.
+         */
+        onDeviceRequestPrompted(listener: (event: { params: Protocol.DeviceAccess.DeviceRequestPromptedEvent }) => void): void;
+        offDeviceRequestPrompted(listener: (event: { params: Protocol.DeviceAccess.DeviceRequestPromptedEvent }) => void): void;
+        onceDeviceRequestPrompted(eventMatcher?: (event: { params: Protocol.DeviceAccess.DeviceRequestPromptedEvent }) => boolean): Promise<{ params: Protocol.DeviceAccess.DeviceRequestPromptedEvent }>;
+
+    }
+
     export interface DeviceOrientationApi {
         /**
          * Clears the overridden Device Orientation.
@@ -2385,16 +2476,226 @@ export namespace ProtocolTestsProxyApi {
         setSmallViewportHeightDifferenceOverride(params: Protocol.Emulation.SetSmallViewportHeightDifferenceOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
-         * Notification sent after the virtual time budget for the current VirtualTimePolicy has run out.
+         * Returns device's screen configuration.
          * @experimental
          */
-        onVirtualTimeBudgetExpired(listener: () => void): void;
-        offVirtualTimeBudgetExpired(listener: () => void): void;
-        onceVirtualTimeBudgetExpired(eventMatcher?: () => boolean): Promise<void>;
-
-    }
+        getScreenInfos(): Promise<{id: number, result: Protocol.Emulation.GetScreenInfosResponse, sessionId: string}>;
 
-    export interface HeadlessExperimentalApi {
+        /**
+         * Add a new screen to the device. Only supported in headless mode.
+         * @experimental
+         */
+        addScreen(params: Protocol.Emulation.AddScreenRequest): Promise<{id: number, result: Protocol.Emulation.AddScreenResponse, sessionId: string}>;
+
+        /**
+         * Remove screen from the device. Only supported in headless mode.
+         * @experimental
+         */
+        removeScreen(params: Protocol.Emulation.RemoveScreenRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Notification sent after the virtual time budget for the current VirtualTimePolicy has run out.
+         * @experimental
+         */
+        onVirtualTimeBudgetExpired(listener: () => void): void;
+        offVirtualTimeBudgetExpired(listener: () => void): void;
+        onceVirtualTimeBudgetExpired(eventMatcher?: () => boolean): Promise<void>;
+
+    }
+
+    export interface EventBreakpointsApi {
+        /**
+         * Sets breakpoint on particular native event.
+         */
+        setInstrumentationBreakpoint(params: Protocol.EventBreakpoints.SetInstrumentationBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Removes breakpoint on particular native event.
+         */
+        removeInstrumentationBreakpoint(params: Protocol.EventBreakpoints.RemoveInstrumentationBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Removes all breakpoints
+         */
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
+
+    }
+
+    export interface ExtensionsApi {
+        /**
+         * Installs an unpacked extension from the filesystem similar to
+         * --load-extension CLI flags. Returns extension ID once the extension
+         * has been installed. Available if the client is connected using the
+         * --remote-debugging-pipe flag and the --enable-unsafe-extension-debugging
+         * flag is set.
+         */
+        loadUnpacked(params: Protocol.Extensions.LoadUnpackedRequest): Promise<{id: number, result: Protocol.Extensions.LoadUnpackedResponse, sessionId: string}>;
+
+        /**
+         * Uninstalls an unpacked extension (others not supported) from the profile.
+         * Available if the client is connected using the --remote-debugging-pipe flag
+         * and the --enable-unsafe-extension-debugging.
+         */
+        uninstall(params: Protocol.Extensions.UninstallRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Gets data from extension storage in the given `storageArea`. If `keys` is
+         * specified, these are used to filter the result.
+         */
+        getStorageItems(params: Protocol.Extensions.GetStorageItemsRequest): Promise<{id: number, result: Protocol.Extensions.GetStorageItemsResponse, sessionId: string}>;
+
+        /**
+         * Removes `keys` from extension storage in the given `storageArea`.
+         */
+        removeStorageItems(params: Protocol.Extensions.RemoveStorageItemsRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Clears extension storage in the given `storageArea`.
+         */
+        clearStorageItems(params: Protocol.Extensions.ClearStorageItemsRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Sets `values` in extension storage in the given `storageArea`. The provided `values`
+         * will be merged with existing values in the storage area.
+         */
+        setStorageItems(params: Protocol.Extensions.SetStorageItemsRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+    }
+
+    export interface FedCmApi {
+        enable(params: Protocol.FedCm.EnableRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
+
+        selectAccount(params: Protocol.FedCm.SelectAccountRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        clickDialogButton(params: Protocol.FedCm.ClickDialogButtonRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        openUrl(params: Protocol.FedCm.OpenUrlRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        dismissDialog(params: Protocol.FedCm.DismissDialogRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Resets the cooldown time, if any, to allow the next FedCM call to show
+         * a dialog even if one was recently dismissed by the user.
+         */
+        resetCooldown(): Promise<{id: number, result: void, sessionId: string}>;
+
+        onDialogShown(listener: (event: { params: Protocol.FedCm.DialogShownEvent }) => void): void;
+        offDialogShown(listener: (event: { params: Protocol.FedCm.DialogShownEvent }) => void): void;
+        onceDialogShown(eventMatcher?: (event: { params: Protocol.FedCm.DialogShownEvent }) => boolean): Promise<{ params: Protocol.FedCm.DialogShownEvent }>;
+
+        /**
+         * Triggered when a dialog is closed, either by user action, JS abort,
+         * or a command below.
+         */
+        onDialogClosed(listener: (event: { params: Protocol.FedCm.DialogClosedEvent }) => void): void;
+        offDialogClosed(listener: (event: { params: Protocol.FedCm.DialogClosedEvent }) => void): void;
+        onceDialogClosed(eventMatcher?: (event: { params: Protocol.FedCm.DialogClosedEvent }) => boolean): Promise<{ params: Protocol.FedCm.DialogClosedEvent }>;
+
+    }
+
+    export interface FetchApi {
+        /**
+         * Disables the fetch domain.
+         */
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Enables issuing of requestPaused events. A request will be paused until client
+         * calls one of failRequest, fulfillRequest or continueRequest/continueWithAuth.
+         */
+        enable(params: Protocol.Fetch.EnableRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Causes the request to fail with specified reason.
+         */
+        failRequest(params: Protocol.Fetch.FailRequestRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Provides response to the request.
+         */
+        fulfillRequest(params: Protocol.Fetch.FulfillRequestRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Continues the request, optionally modifying some of its parameters.
+         */
+        continueRequest(params: Protocol.Fetch.ContinueRequestRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Continues a request supplying authChallengeResponse following authRequired event.
+         */
+        continueWithAuth(params: Protocol.Fetch.ContinueWithAuthRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Continues loading of the paused response, optionally modifying the
+         * response headers. If either responseCode or headers are modified, all of them
+         * must be present.
+         * @experimental
+         */
+        continueResponse(params: Protocol.Fetch.ContinueResponseRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Causes the body of the response to be received from the server and
+         * returned as a single string. May only be issued for a request that
+         * is paused in the Response stage and is mutually exclusive with
+         * takeResponseBodyForInterceptionAsStream. Calling other methods that
+         * affect the request or disabling fetch domain before body is received
+         * results in an undefined behavior.
+         * Note that the response body is not available for redirects. Requests
+         * paused in the _redirect received_ state may be differentiated by
+         * `responseCode` and presence of `location` response header, see
+         * comments to `requestPaused` for details.
+         */
+        getResponseBody(params: Protocol.Fetch.GetResponseBodyRequest): Promise<{id: number, result: Protocol.Fetch.GetResponseBodyResponse, sessionId: string}>;
+
+        /**
+         * Returns a handle to the stream representing the response body.
+         * The request must be paused in the HeadersReceived stage.
+         * Note that after this command the request can't be continued
+         * as is -- client either needs to cancel it or to provide the
+         * response body.
+         * The stream only supports sequential read, IO.read will fail if the position
+         * is specified.
+         * This method is mutually exclusive with getResponseBody.
+         * Calling other methods that affect the request or disabling fetch
+         * domain before body is received results in an undefined behavior.
+         */
+        takeResponseBodyAsStream(params: Protocol.Fetch.TakeResponseBodyAsStreamRequest): Promise<{id: number, result: Protocol.Fetch.TakeResponseBodyAsStreamResponse, sessionId: string}>;
+
+        /**
+         * Issued when the domain is enabled and the request URL matches the
+         * specified filter. The request is paused until the client responds
+         * with one of continueRequest, failRequest or fulfillRequest.
+         * The stage of the request can be determined by presence of responseErrorReason
+         * and responseStatusCode -- the request is at the response stage if either
+         * of these fields is present and in the request stage otherwise.
+         * Redirect responses and subsequent requests are reported similarly to regular
+         * responses and requests. Redirect responses may be distinguished by the value
+         * of `responseStatusCode` (which is one of 301, 302, 303, 307, 308) along with
+         * presence of the `location` header. Requests resulting from a redirect will
+         * have `redirectedRequestId` field set.
+         */
+        onRequestPaused(listener: (event: { params: Protocol.Fetch.RequestPausedEvent }) => void): void;
+        offRequestPaused(listener: (event: { params: Protocol.Fetch.RequestPausedEvent }) => void): void;
+        onceRequestPaused(eventMatcher?: (event: { params: Protocol.Fetch.RequestPausedEvent }) => boolean): Promise<{ params: Protocol.Fetch.RequestPausedEvent }>;
+
+        /**
+         * Issued when the domain is enabled with handleAuthRequests set to true.
+         * The request is paused until client responds with continueWithAuth.
+         */
+        onAuthRequired(listener: (event: { params: Protocol.Fetch.AuthRequiredEvent }) => void): void;
+        offAuthRequired(listener: (event: { params: Protocol.Fetch.AuthRequiredEvent }) => void): void;
+        onceAuthRequired(eventMatcher?: (event: { params: Protocol.Fetch.AuthRequiredEvent }) => boolean): Promise<{ params: Protocol.Fetch.AuthRequiredEvent }>;
+
+    }
+
+    export interface FileSystemApi {
+        getDirectory(params: Protocol.FileSystem.GetDirectoryRequest): Promise<{id: number, result: Protocol.FileSystem.GetDirectoryResponse, sessionId: string}>;
+
+    }
+
+    export interface HeadlessExperimentalApi {
         /**
          * Sends a BeginFrame to the target and returns when the frame was completed. Optionally captures a
          * screenshot from the resulting frame. Requires that the target was created with enabled
@@ -2435,11 +2736,6 @@ export namespace ProtocolTestsProxyApi {
 
     }
 
-    export interface FileSystemApi {
-        getDirectory(params: Protocol.FileSystem.GetDirectoryRequest): Promise<{id: number, result: Protocol.FileSystem.GetDirectoryResponse, sessionId: string}>;
-
-    }
-
     export interface IndexedDBApi {
         /**
          * Clears all entries from an object store.
@@ -2700,42 +2996,94 @@ export namespace ProtocolTestsProxyApi {
 
     }
 
-    export interface MemoryApi {
+    export interface MediaApi {
         /**
-         * Retruns current DOM object counters.
+         * Enables the Media domain
          */
-        getDOMCounters(): Promise<{id: number, result: Protocol.Memory.GetDOMCountersResponse, sessionId: string}>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
-         * Retruns DOM object counters after preparing renderer for leak detection.
+         * Disables the Media domain.
          */
-        getDOMCountersForLeakDetection(): Promise<{id: number, result: Protocol.Memory.GetDOMCountersForLeakDetectionResponse, sessionId: string}>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
-         * Prepares for leak detection by terminating workers, stopping spellcheckers,
-         * dropping non-essential internal caches, running garbage collections, etc.
+         * This can be called multiple times, and can be used to set / override /
+         * remove player properties. A null propValue indicates removal.
          */
-        prepareForLeakDetection(): Promise<{id: number, result: void, sessionId: string}>;
+        onPlayerPropertiesChanged(listener: (event: { params: Protocol.Media.PlayerPropertiesChangedEvent }) => void): void;
+        offPlayerPropertiesChanged(listener: (event: { params: Protocol.Media.PlayerPropertiesChangedEvent }) => void): void;
+        oncePlayerPropertiesChanged(eventMatcher?: (event: { params: Protocol.Media.PlayerPropertiesChangedEvent }) => boolean): Promise<{ params: Protocol.Media.PlayerPropertiesChangedEvent }>;
 
         /**
-         * Simulate OomIntervention by purging V8 memory.
+         * Send events as a list, allowing them to be batched on the browser for less
+         * congestion. If batched, events must ALWAYS be in chronological order.
          */
-        forciblyPurgeJavaScriptMemory(): Promise<{id: number, result: void, sessionId: string}>;
+        onPlayerEventsAdded(listener: (event: { params: Protocol.Media.PlayerEventsAddedEvent }) => void): void;
+        offPlayerEventsAdded(listener: (event: { params: Protocol.Media.PlayerEventsAddedEvent }) => void): void;
+        oncePlayerEventsAdded(eventMatcher?: (event: { params: Protocol.Media.PlayerEventsAddedEvent }) => boolean): Promise<{ params: Protocol.Media.PlayerEventsAddedEvent }>;
 
         /**
-         * Enable/disable suppressing memory pressure notifications in all processes.
+         * Send a list of any messages that need to be delivered.
          */
-        setPressureNotificationsSuppressed(params: Protocol.Memory.SetPressureNotificationsSuppressedRequest): Promise<{id: number, result: void, sessionId: string}>;
+        onPlayerMessagesLogged(listener: (event: { params: Protocol.Media.PlayerMessagesLoggedEvent }) => void): void;
+        offPlayerMessagesLogged(listener: (event: { params: Protocol.Media.PlayerMessagesLoggedEvent }) => void): void;
+        oncePlayerMessagesLogged(eventMatcher?: (event: { params: Protocol.Media.PlayerMessagesLoggedEvent }) => boolean): Promise<{ params: Protocol.Media.PlayerMessagesLoggedEvent }>;
 
         /**
-         * Simulate a memory pressure notification in all processes.
+         * Send a list of any errors that need to be delivered.
          */
-        simulatePressureNotification(params: Protocol.Memory.SimulatePressureNotificationRequest): Promise<{id: number, result: void, sessionId: string}>;
+        onPlayerErrorsRaised(listener: (event: { params: Protocol.Media.PlayerErrorsRaisedEvent }) => void): void;
+        offPlayerErrorsRaised(listener: (event: { params: Protocol.Media.PlayerErrorsRaisedEvent }) => void): void;
+        oncePlayerErrorsRaised(eventMatcher?: (event: { params: Protocol.Media.PlayerErrorsRaisedEvent }) => boolean): Promise<{ params: Protocol.Media.PlayerErrorsRaisedEvent }>;
 
         /**
-         * Start collecting native memory profile.
-         */
-        startSampling(params: Protocol.Memory.StartSamplingRequest): Promise<{id: number, result: void, sessionId: string}>;
+         * Called whenever a player is created, or when a new agent joins and receives
+         * a list of active players. If an agent is restored, it will receive the full
+         * list of player ids and all events again.
+         */
+        onPlayersCreated(listener: (event: { params: Protocol.Media.PlayersCreatedEvent }) => void): void;
+        offPlayersCreated(listener: (event: { params: Protocol.Media.PlayersCreatedEvent }) => void): void;
+        oncePlayersCreated(eventMatcher?: (event: { params: Protocol.Media.PlayersCreatedEvent }) => boolean): Promise<{ params: Protocol.Media.PlayersCreatedEvent }>;
+
+    }
+
+    export interface MemoryApi {
+        /**
+         * Retruns current DOM object counters.
+         */
+        getDOMCounters(): Promise<{id: number, result: Protocol.Memory.GetDOMCountersResponse, sessionId: string}>;
+
+        /**
+         * Retruns DOM object counters after preparing renderer for leak detection.
+         */
+        getDOMCountersForLeakDetection(): Promise<{id: number, result: Protocol.Memory.GetDOMCountersForLeakDetectionResponse, sessionId: string}>;
+
+        /**
+         * Prepares for leak detection by terminating workers, stopping spellcheckers,
+         * dropping non-essential internal caches, running garbage collections, etc.
+         */
+        prepareForLeakDetection(): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Simulate OomIntervention by purging V8 memory.
+         */
+        forciblyPurgeJavaScriptMemory(): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Enable/disable suppressing memory pressure notifications in all processes.
+         */
+        setPressureNotificationsSuppressed(params: Protocol.Memory.SetPressureNotificationsSuppressedRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Simulate a memory pressure notification in all processes.
+         */
+        simulatePressureNotification(params: Protocol.Memory.SimulatePressureNotificationRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Start collecting native memory profile.
+         */
+        startSampling(params: Protocol.Memory.StartSamplingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Stop collecting native memory profile.
@@ -3380,6 +3728,9 @@ export namespace ProtocolTestsProxyApi {
 
         /**
          * Highlights given rectangle. Coordinates are absolute with respect to the main frame viewport.
+         * Issue: the method does not handle device pixel ratio (DPR) correctly.
+         * The coordinates currently have to be adjusted by the client
+         * if DPR is not 1 (see crbug.com/437807128).
          */
         highlightRect(params: Protocol.Overlay.HighlightRectRequest): Promise<{id: number, result: void, sessionId: string}>;
 
@@ -3501,6 +3852,92 @@ export namespace ProtocolTestsProxyApi {
 
     }
 
+    export interface PWAApi {
+        /**
+         * Returns the following OS state for the given manifest id.
+         */
+        getOsAppState(params: Protocol.PWA.GetOsAppStateRequest): Promise<{id: number, result: Protocol.PWA.GetOsAppStateResponse, sessionId: string}>;
+
+        /**
+         * Installs the given manifest identity, optionally using the given installUrlOrBundleUrl
+         * 
+         * IWA-specific install description:
+         * manifestId corresponds to isolated-app:// + web_package::SignedWebBundleId
+         * 
+         * File installation mode:
+         * The installUrlOrBundleUrl can be either file:// or http(s):// pointing
+         * to a signed web bundle (.swbn). In this case SignedWebBundleId must correspond to
+         * The .swbn file's signing key.
+         * 
+         * Dev proxy installation mode:
+         * installUrlOrBundleUrl must be http(s):// that serves dev mode IWA.
+         * web_package::SignedWebBundleId must be of type dev proxy.
+         * 
+         * The advantage of dev proxy mode is that all changes to IWA
+         * automatically will be reflected in the running app without
+         * reinstallation.
+         * 
+         * To generate bundle id for proxy mode:
+         * 1. Generate 32 random bytes.
+         * 2. Add a specific suffix 0x00 at the end.
+         * 3. Encode the entire sequence using Base32 without padding.
+         * 
+         * If Chrome is not in IWA dev
+         * mode, the installation will fail, regardless of the state of the allowlist.
+         */
+        install(params: Protocol.PWA.InstallRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Uninstalls the given manifest_id and closes any opened app windows.
+         */
+        uninstall(params: Protocol.PWA.UninstallRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Launches the installed web app, or an url in the same web app instead of the
+         * default start url if it is provided. Returns a page Target.TargetID which
+         * can be used to attach to via Target.attachToTarget or similar APIs.
+         */
+        launch(params: Protocol.PWA.LaunchRequest): Promise<{id: number, result: Protocol.PWA.LaunchResponse, sessionId: string}>;
+
+        /**
+         * Opens one or more local files from an installed web app identified by its
+         * manifestId. The web app needs to have file handlers registered to process
+         * the files. The API returns one or more page Target.TargetIDs which can be
+         * used to attach to via Target.attachToTarget or similar APIs.
+         * If some files in the parameters cannot be handled by the web app, they will
+         * be ignored. If none of the files can be handled, this API returns an error.
+         * If no files are provided as the parameter, this API also returns an error.
+         * 
+         * According to the definition of the file handlers in the manifest file, one
+         * Target.TargetID may represent a page handling one or more files. The order
+         * of the returned Target.TargetIDs is not guaranteed.
+         * 
+         * TODO(crbug.com/339454034): Check the existences of the input files.
+         */
+        launchFilesInApp(params: Protocol.PWA.LaunchFilesInAppRequest): Promise<{id: number, result: Protocol.PWA.LaunchFilesInAppResponse, sessionId: string}>;
+
+        /**
+         * Opens the current page in its web app identified by the manifest id, needs
+         * to be called on a page target. This function returns immediately without
+         * waiting for the app to finish loading.
+         */
+        openCurrentPageInApp(params: Protocol.PWA.OpenCurrentPageInAppRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Changes user settings of the web app identified by its manifestId. If the
+         * app was not installed, this command returns an error. Unset parameters will
+         * be ignored; unrecognized values will cause an error.
+         * 
+         * Unlike the ones defined in the manifest files of the web apps, these
+         * settings are provided by the browser and controlled by the users, they
+         * impact the way the browser handling the web apps.
+         * 
+         * See the comment of each parameter.
+         */
+        changeAppUserSettings(params: Protocol.PWA.ChangeAppUserSettingsRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+    }
+
     export interface PageApi {
         /**
          * Deprecated, please use addScriptToEvaluateOnNewDocument instead.
@@ -4150,6 +4587,52 @@ export namespace ProtocolTestsProxyApi {
 
     }
 
+    export interface PreloadApi {
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
+
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Upsert. Currently, it is only emitted when a rule set added.
+         */
+        onRuleSetUpdated(listener: (event: { params: Protocol.Preload.RuleSetUpdatedEvent }) => void): void;
+        offRuleSetUpdated(listener: (event: { params: Protocol.Preload.RuleSetUpdatedEvent }) => void): void;
+        onceRuleSetUpdated(eventMatcher?: (event: { params: Protocol.Preload.RuleSetUpdatedEvent }) => boolean): Promise<{ params: Protocol.Preload.RuleSetUpdatedEvent }>;
+
+        onRuleSetRemoved(listener: (event: { params: Protocol.Preload.RuleSetRemovedEvent }) => void): void;
+        offRuleSetRemoved(listener: (event: { params: Protocol.Preload.RuleSetRemovedEvent }) => void): void;
+        onceRuleSetRemoved(eventMatcher?: (event: { params: Protocol.Preload.RuleSetRemovedEvent }) => boolean): Promise<{ params: Protocol.Preload.RuleSetRemovedEvent }>;
+
+        /**
+         * Fired when a preload enabled state is updated.
+         */
+        onPreloadEnabledStateUpdated(listener: (event: { params: Protocol.Preload.PreloadEnabledStateUpdatedEvent }) => void): void;
+        offPreloadEnabledStateUpdated(listener: (event: { params: Protocol.Preload.PreloadEnabledStateUpdatedEvent }) => void): void;
+        oncePreloadEnabledStateUpdated(eventMatcher?: (event: { params: Protocol.Preload.PreloadEnabledStateUpdatedEvent }) => boolean): Promise<{ params: Protocol.Preload.PreloadEnabledStateUpdatedEvent }>;
+
+        /**
+         * Fired when a prefetch attempt is updated.
+         */
+        onPrefetchStatusUpdated(listener: (event: { params: Protocol.Preload.PrefetchStatusUpdatedEvent }) => void): void;
+        offPrefetchStatusUpdated(listener: (event: { params: Protocol.Preload.PrefetchStatusUpdatedEvent }) => void): void;
+        oncePrefetchStatusUpdated(eventMatcher?: (event: { params: Protocol.Preload.PrefetchStatusUpdatedEvent }) => boolean): Promise<{ params: Protocol.Preload.PrefetchStatusUpdatedEvent }>;
+
+        /**
+         * Fired when a prerender attempt is updated.
+         */
+        onPrerenderStatusUpdated(listener: (event: { params: Protocol.Preload.PrerenderStatusUpdatedEvent }) => void): void;
+        offPrerenderStatusUpdated(listener: (event: { params: Protocol.Preload.PrerenderStatusUpdatedEvent }) => void): void;
+        oncePrerenderStatusUpdated(eventMatcher?: (event: { params: Protocol.Preload.PrerenderStatusUpdatedEvent }) => boolean): Promise<{ params: Protocol.Preload.PrerenderStatusUpdatedEvent }>;
+
+        /**
+         * Send a list of sources for all preloading attempts in a document.
+         */
+        onPreloadingAttemptSourcesUpdated(listener: (event: { params: Protocol.Preload.PreloadingAttemptSourcesUpdatedEvent }) => void): void;
+        offPreloadingAttemptSourcesUpdated(listener: (event: { params: Protocol.Preload.PreloadingAttemptSourcesUpdatedEvent }) => void): void;
+        oncePreloadingAttemptSourcesUpdated(eventMatcher?: (event: { params: Protocol.Preload.PreloadingAttemptSourcesUpdatedEvent }) => boolean): Promise<{ params: Protocol.Preload.PreloadingAttemptSourcesUpdatedEvent }>;
+
+    }
+
     export interface SecurityApi {
         /**
          * Disables tracking security state changes.
@@ -4837,165 +5320,70 @@ export namespace ProtocolTestsProxyApi {
 
     }
 
-    export interface FetchApi {
+    export interface WebAudioApi {
         /**
-         * Disables the fetch domain.
+         * Enables the WebAudio domain and starts sending context lifetime events.
+         */
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Disables the WebAudio domain.
          */
         disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
-         * Enables issuing of requestPaused events. A request will be paused until client
-         * calls one of failRequest, fulfillRequest or continueRequest/continueWithAuth.
+         * Fetch the realtime data from the registered contexts.
          */
-        enable(params: Protocol.Fetch.EnableRequest): Promise<{id: number, result: void, sessionId: string}>;
+        getRealtimeData(params: Protocol.WebAudio.GetRealtimeDataRequest): Promise<{id: number, result: Protocol.WebAudio.GetRealtimeDataResponse, sessionId: string}>;
 
         /**
-         * Causes the request to fail with specified reason.
+         * Notifies that a new BaseAudioContext has been created.
          */
-        failRequest(params: Protocol.Fetch.FailRequestRequest): Promise<{id: number, result: void, sessionId: string}>;
+        onContextCreated(listener: (event: { params: Protocol.WebAudio.ContextCreatedEvent }) => void): void;
+        offContextCreated(listener: (event: { params: Protocol.WebAudio.ContextCreatedEvent }) => void): void;
+        onceContextCreated(eventMatcher?: (event: { params: Protocol.WebAudio.ContextCreatedEvent }) => boolean): Promise<{ params: Protocol.WebAudio.ContextCreatedEvent }>;
 
         /**
-         * Provides response to the request.
+         * Notifies that an existing BaseAudioContext will be destroyed.
          */
-        fulfillRequest(params: Protocol.Fetch.FulfillRequestRequest): Promise<{id: number, result: void, sessionId: string}>;
+        onContextWillBeDestroyed(listener: (event: { params: Protocol.WebAudio.ContextWillBeDestroyedEvent }) => void): void;
+        offContextWillBeDestroyed(listener: (event: { params: Protocol.WebAudio.ContextWillBeDestroyedEvent }) => void): void;
+        onceContextWillBeDestroyed(eventMatcher?: (event: { params: Protocol.WebAudio.ContextWillBeDestroyedEvent }) => boolean): Promise<{ params: Protocol.WebAudio.ContextWillBeDestroyedEvent }>;
 
         /**
-         * Continues the request, optionally modifying some of its parameters.
+         * Notifies that existing BaseAudioContext has changed some properties (id stays the same)..
          */
-        continueRequest(params: Protocol.Fetch.ContinueRequestRequest): Promise<{id: number, result: void, sessionId: string}>;
+        onContextChanged(listener: (event: { params: Protocol.WebAudio.ContextChangedEvent }) => void): void;
+        offContextChanged(listener: (event: { params: Protocol.WebAudio.ContextChangedEvent }) => void): void;
+        onceContextChanged(eventMatcher?: (event: { params: Protocol.WebAudio.ContextChangedEvent }) => boolean): Promise<{ params: Protocol.WebAudio.ContextChangedEvent }>;
 
         /**
-         * Continues a request supplying authChallengeResponse following authRequired event.
+         * Notifies that the construction of an AudioListener has finished.
          */
-        continueWithAuth(params: Protocol.Fetch.ContinueWithAuthRequest): Promise<{id: number, result: void, sessionId: string}>;
+        onAudioListenerCreated(listener: (event: { params: Protocol.WebAudio.AudioListenerCreatedEvent }) => void): void;
+        offAudioListenerCreated(listener: (event: { params: Protocol.WebAudio.AudioListenerCreatedEvent }) => void): void;
+        onceAudioListenerCreated(eventMatcher?: (event: { params: Protocol.WebAudio.AudioListenerCreatedEvent }) => boolean): Promise<{ params: Protocol.WebAudio.AudioListenerCreatedEvent }>;
 
         /**
-         * Continues loading of the paused response, optionally modifying the
-         * response headers. If either responseCode or headers are modified, all of them
-         * must be present.
-         * @experimental
+         * Notifies that a new AudioListener has been created.
          */
-        continueResponse(params: Protocol.Fetch.ContinueResponseRequest): Promise<{id: number, result: void, sessionId: string}>;
+        onAudioListenerWillBeDestroyed(listener: (event: { params: Protocol.WebAudio.AudioListenerWillBeDestroyedEvent }) => void): void;
+        offAudioListenerWillBeDestroyed(listener: (event: { params: Protocol.WebAudio.AudioListenerWillBeDestroyedEvent }) => void): void;
+        onceAudioListenerWillBeDestroyed(eventMatcher?: (event: { params: Protocol.WebAudio.AudioListenerWillBeDestroyedEvent }) => boolean): Promise<{ params: Protocol.WebAudio.AudioListenerWillBeDestroyedEvent }>;
 
         /**
-         * Causes the body of the response to be received from the server and
-         * returned as a single string. May only be issued for a request that
-         * is paused in the Response stage and is mutually exclusive with
-         * takeResponseBodyForInterceptionAsStream. Calling other methods that
-         * affect the request or disabling fetch domain before body is received
-         * results in an undefined behavior.
-         * Note that the response body is not available for redirects. Requests
-         * paused in the _redirect received_ state may be differentiated by
-         * `responseCode` and presence of `location` response header, see
-         * comments to `requestPaused` for details.
+         * Notifies that a new AudioNode has been created.
          */
-        getResponseBody(params: Protocol.Fetch.GetResponseBodyRequest): Promise<{id: number, result: Protocol.Fetch.GetResponseBodyResponse, sessionId: string}>;
+        onAudioNodeCreated(listener: (event: { params: Protocol.WebAudio.AudioNodeCreatedEvent }) => void): void;
+        offAudioNodeCreated(listener: (event: { params: Protocol.WebAudio.AudioNodeCreatedEvent }) => void): void;
+        onceAudioNodeCreated(eventMatcher?: (event: { params: Protocol.WebAudio.AudioNodeCreatedEvent }) => boolean): Promise<{ params: Protocol.WebAudio.AudioNodeCreatedEvent }>;
 
         /**
-         * Returns a handle to the stream representing the response body.
-         * The request must be paused in the HeadersReceived stage.
-         * Note that after this command the request can't be continued
-         * as is -- client either needs to cancel it or to provide the
-         * response body.
-         * The stream only supports sequential read, IO.read will fail if the position
-         * is specified.
-         * This method is mutually exclusive with getResponseBody.
-         * Calling other methods that affect the request or disabling fetch
-         * domain before body is received results in an undefined behavior.
+         * Notifies that an existing AudioNode has been destroyed.
          */
-        takeResponseBodyAsStream(params: Protocol.Fetch.TakeResponseBodyAsStreamRequest): Promise<{id: number, result: Protocol.Fetch.TakeResponseBodyAsStreamResponse, sessionId: string}>;
-
-        /**
-         * Issued when the domain is enabled and the request URL matches the
-         * specified filter. The request is paused until the client responds
-         * with one of continueRequest, failRequest or fulfillRequest.
-         * The stage of the request can be determined by presence of responseErrorReason
-         * and responseStatusCode -- the request is at the response stage if either
-         * of these fields is present and in the request stage otherwise.
-         * Redirect responses and subsequent requests are reported similarly to regular
-         * responses and requests. Redirect responses may be distinguished by the value
-         * of `responseStatusCode` (which is one of 301, 302, 303, 307, 308) along with
-         * presence of the `location` header. Requests resulting from a redirect will
-         * have `redirectedRequestId` field set.
-         */
-        onRequestPaused(listener: (event: { params: Protocol.Fetch.RequestPausedEvent }) => void): void;
-        offRequestPaused(listener: (event: { params: Protocol.Fetch.RequestPausedEvent }) => void): void;
-        onceRequestPaused(eventMatcher?: (event: { params: Protocol.Fetch.RequestPausedEvent }) => boolean): Promise<{ params: Protocol.Fetch.RequestPausedEvent }>;
-
-        /**
-         * Issued when the domain is enabled with handleAuthRequests set to true.
-         * The request is paused until client responds with continueWithAuth.
-         */
-        onAuthRequired(listener: (event: { params: Protocol.Fetch.AuthRequiredEvent }) => void): void;
-        offAuthRequired(listener: (event: { params: Protocol.Fetch.AuthRequiredEvent }) => void): void;
-        onceAuthRequired(eventMatcher?: (event: { params: Protocol.Fetch.AuthRequiredEvent }) => boolean): Promise<{ params: Protocol.Fetch.AuthRequiredEvent }>;
-
-    }
-
-    export interface WebAudioApi {
-        /**
-         * Enables the WebAudio domain and starts sending context lifetime events.
-         */
-        enable(): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Disables the WebAudio domain.
-         */
-        disable(): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Fetch the realtime data from the registered contexts.
-         */
-        getRealtimeData(params: Protocol.WebAudio.GetRealtimeDataRequest): Promise<{id: number, result: Protocol.WebAudio.GetRealtimeDataResponse, sessionId: string}>;
-
-        /**
-         * Notifies that a new BaseAudioContext has been created.
-         */
-        onContextCreated(listener: (event: { params: Protocol.WebAudio.ContextCreatedEvent }) => void): void;
-        offContextCreated(listener: (event: { params: Protocol.WebAudio.ContextCreatedEvent }) => void): void;
-        onceContextCreated(eventMatcher?: (event: { params: Protocol.WebAudio.ContextCreatedEvent }) => boolean): Promise<{ params: Protocol.WebAudio.ContextCreatedEvent }>;
-
-        /**
-         * Notifies that an existing BaseAudioContext will be destroyed.
-         */
-        onContextWillBeDestroyed(listener: (event: { params: Protocol.WebAudio.ContextWillBeDestroyedEvent }) => void): void;
-        offContextWillBeDestroyed(listener: (event: { params: Protocol.WebAudio.ContextWillBeDestroyedEvent }) => void): void;
-        onceContextWillBeDestroyed(eventMatcher?: (event: { params: Protocol.WebAudio.ContextWillBeDestroyedEvent }) => boolean): Promise<{ params: Protocol.WebAudio.ContextWillBeDestroyedEvent }>;
-
-        /**
-         * Notifies that existing BaseAudioContext has changed some properties (id stays the same)..
-         */
-        onContextChanged(listener: (event: { params: Protocol.WebAudio.ContextChangedEvent }) => void): void;
-        offContextChanged(listener: (event: { params: Protocol.WebAudio.ContextChangedEvent }) => void): void;
-        onceContextChanged(eventMatcher?: (event: { params: Protocol.WebAudio.ContextChangedEvent }) => boolean): Promise<{ params: Protocol.WebAudio.ContextChangedEvent }>;
-
-        /**
-         * Notifies that the construction of an AudioListener has finished.
-         */
-        onAudioListenerCreated(listener: (event: { params: Protocol.WebAudio.AudioListenerCreatedEvent }) => void): void;
-        offAudioListenerCreated(listener: (event: { params: Protocol.WebAudio.AudioListenerCreatedEvent }) => void): void;
-        onceAudioListenerCreated(eventMatcher?: (event: { params: Protocol.WebAudio.AudioListenerCreatedEvent }) => boolean): Promise<{ params: Protocol.WebAudio.AudioListenerCreatedEvent }>;
-
-        /**
-         * Notifies that a new AudioListener has been created.
-         */
-        onAudioListenerWillBeDestroyed(listener: (event: { params: Protocol.WebAudio.AudioListenerWillBeDestroyedEvent }) => void): void;
-        offAudioListenerWillBeDestroyed(listener: (event: { params: Protocol.WebAudio.AudioListenerWillBeDestroyedEvent }) => void): void;
-        onceAudioListenerWillBeDestroyed(eventMatcher?: (event: { params: Protocol.WebAudio.AudioListenerWillBeDestroyedEvent }) => boolean): Promise<{ params: Protocol.WebAudio.AudioListenerWillBeDestroyedEvent }>;
-
-        /**
-         * Notifies that a new AudioNode has been created.
-         */
-        onAudioNodeCreated(listener: (event: { params: Protocol.WebAudio.AudioNodeCreatedEvent }) => void): void;
-        offAudioNodeCreated(listener: (event: { params: Protocol.WebAudio.AudioNodeCreatedEvent }) => void): void;
-        onceAudioNodeCreated(eventMatcher?: (event: { params: Protocol.WebAudio.AudioNodeCreatedEvent }) => boolean): Promise<{ params: Protocol.WebAudio.AudioNodeCreatedEvent }>;
-
-        /**
-         * Notifies that an existing AudioNode has been destroyed.
-         */
-        onAudioNodeWillBeDestroyed(listener: (event: { params: Protocol.WebAudio.AudioNodeWillBeDestroyedEvent }) => void): void;
-        offAudioNodeWillBeDestroyed(listener: (event: { params: Protocol.WebAudio.AudioNodeWillBeDestroyedEvent }) => void): void;
-        onceAudioNodeWillBeDestroyed(eventMatcher?: (event: { params: Protocol.WebAudio.AudioNodeWillBeDestroyedEvent }) => boolean): Promise<{ params: Protocol.WebAudio.AudioNodeWillBeDestroyedEvent }>;
+        onAudioNodeWillBeDestroyed(listener: (event: { params: Protocol.WebAudio.AudioNodeWillBeDestroyedEvent }) => void): void;
+        offAudioNodeWillBeDestroyed(listener: (event: { params: Protocol.WebAudio.AudioNodeWillBeDestroyedEvent }) => void): void;
+        onceAudioNodeWillBeDestroyed(eventMatcher?: (event: { params: Protocol.WebAudio.AudioNodeWillBeDestroyedEvent }) => boolean): Promise<{ params: Protocol.WebAudio.AudioNodeWillBeDestroyedEvent }>;
 
         /**
          * Notifies that a new AudioParam has been created.
@@ -5143,373 +5531,6 @@ export namespace ProtocolTestsProxyApi {
         onceCredentialAsserted(eventMatcher?: (event: { params: Protocol.WebAuthn.CredentialAssertedEvent }) => boolean): Promise<{ params: Protocol.WebAuthn.CredentialAssertedEvent }>;
 
     }
-
-    export interface MediaApi {
-        /**
-         * Enables the Media domain
-         */
-        enable(): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Disables the Media domain.
-         */
-        disable(): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * This can be called multiple times, and can be used to set / override /
-         * remove player properties. A null propValue indicates removal.
-         */
-        onPlayerPropertiesChanged(listener: (event: { params: Protocol.Media.PlayerPropertiesChangedEvent }) => void): void;
-        offPlayerPropertiesChanged(listener: (event: { params: Protocol.Media.PlayerPropertiesChangedEvent }) => void): void;
-        oncePlayerPropertiesChanged(eventMatcher?: (event: { params: Protocol.Media.PlayerPropertiesChangedEvent }) => boolean): Promise<{ params: Protocol.Media.PlayerPropertiesChangedEvent }>;
-
-        /**
-         * Send events as a list, allowing them to be batched on the browser for less
-         * congestion. If batched, events must ALWAYS be in chronological order.
-         */
-        onPlayerEventsAdded(listener: (event: { params: Protocol.Media.PlayerEventsAddedEvent }) => void): void;
-        offPlayerEventsAdded(listener: (event: { params: Protocol.Media.PlayerEventsAddedEvent }) => void): void;
-        oncePlayerEventsAdded(eventMatcher?: (event: { params: Protocol.Media.PlayerEventsAddedEvent }) => boolean): Promise<{ params: Protocol.Media.PlayerEventsAddedEvent }>;
-
-        /**
-         * Send a list of any messages that need to be delivered.
-         */
-        onPlayerMessagesLogged(listener: (event: { params: Protocol.Media.PlayerMessagesLoggedEvent }) => void): void;
-        offPlayerMessagesLogged(listener: (event: { params: Protocol.Media.PlayerMessagesLoggedEvent }) => void): void;
-        oncePlayerMessagesLogged(eventMatcher?: (event: { params: Protocol.Media.PlayerMessagesLoggedEvent }) => boolean): Promise<{ params: Protocol.Media.PlayerMessagesLoggedEvent }>;
-
-        /**
-         * Send a list of any errors that need to be delivered.
-         */
-        onPlayerErrorsRaised(listener: (event: { params: Protocol.Media.PlayerErrorsRaisedEvent }) => void): void;
-        offPlayerErrorsRaised(listener: (event: { params: Protocol.Media.PlayerErrorsRaisedEvent }) => void): void;
-        oncePlayerErrorsRaised(eventMatcher?: (event: { params: Protocol.Media.PlayerErrorsRaisedEvent }) => boolean): Promise<{ params: Protocol.Media.PlayerErrorsRaisedEvent }>;
-
-        /**
-         * Called whenever a player is created, or when a new agent joins and receives
-         * a list of active players. If an agent is restored, it will receive the full
-         * list of player ids and all events again.
-         */
-        onPlayersCreated(listener: (event: { params: Protocol.Media.PlayersCreatedEvent }) => void): void;
-        offPlayersCreated(listener: (event: { params: Protocol.Media.PlayersCreatedEvent }) => void): void;
-        oncePlayersCreated(eventMatcher?: (event: { params: Protocol.Media.PlayersCreatedEvent }) => boolean): Promise<{ params: Protocol.Media.PlayersCreatedEvent }>;
-
-    }
-
-    export interface DeviceAccessApi {
-        /**
-         * Enable events in this domain.
-         */
-        enable(): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Disable events in this domain.
-         */
-        disable(): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Select a device in response to a DeviceAccess.deviceRequestPrompted event.
-         */
-        selectPrompt(params: Protocol.DeviceAccess.SelectPromptRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Cancel a prompt in response to a DeviceAccess.deviceRequestPrompted event.
-         */
-        cancelPrompt(params: Protocol.DeviceAccess.CancelPromptRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * A device request opened a user prompt to select a device. Respond with the
-         * selectPrompt or cancelPrompt command.
-         */
-        onDeviceRequestPrompted(listener: (event: { params: Protocol.DeviceAccess.DeviceRequestPromptedEvent }) => void): void;
-        offDeviceRequestPrompted(listener: (event: { params: Protocol.DeviceAccess.DeviceRequestPromptedEvent }) => void): void;
-        onceDeviceRequestPrompted(eventMatcher?: (event: { params: Protocol.DeviceAccess.DeviceRequestPromptedEvent }) => boolean): Promise<{ params: Protocol.DeviceAccess.DeviceRequestPromptedEvent }>;
-
-    }
-
-    export interface PreloadApi {
-        enable(): Promise<{id: number, result: void, sessionId: string}>;
-
-        disable(): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Upsert. Currently, it is only emitted when a rule set added.
-         */
-        onRuleSetUpdated(listener: (event: { params: Protocol.Preload.RuleSetUpdatedEvent }) => void): void;
-        offRuleSetUpdated(listener: (event: { params: Protocol.Preload.RuleSetUpdatedEvent }) => void): void;
-        onceRuleSetUpdated(eventMatcher?: (event: { params: Protocol.Preload.RuleSetUpdatedEvent }) => boolean): Promise<{ params: Protocol.Preload.RuleSetUpdatedEvent }>;
-
-        onRuleSetRemoved(listener: (event: { params: Protocol.Preload.RuleSetRemovedEvent }) => void): void;
-        offRuleSetRemoved(listener: (event: { params: Protocol.Preload.RuleSetRemovedEvent }) => void): void;
-        onceRuleSetRemoved(eventMatcher?: (event: { params: Protocol.Preload.RuleSetRemovedEvent }) => boolean): Promise<{ params: Protocol.Preload.RuleSetRemovedEvent }>;
-
-        /**
-         * Fired when a preload enabled state is updated.
-         */
-        onPreloadEnabledStateUpdated(listener: (event: { params: Protocol.Preload.PreloadEnabledStateUpdatedEvent }) => void): void;
-        offPreloadEnabledStateUpdated(listener: (event: { params: Protocol.Preload.PreloadEnabledStateUpdatedEvent }) => void): void;
-        oncePreloadEnabledStateUpdated(eventMatcher?: (event: { params: Protocol.Preload.PreloadEnabledStateUpdatedEvent }) => boolean): Promise<{ params: Protocol.Preload.PreloadEnabledStateUpdatedEvent }>;
-
-        /**
-         * Fired when a prefetch attempt is updated.
-         */
-        onPrefetchStatusUpdated(listener: (event: { params: Protocol.Preload.PrefetchStatusUpdatedEvent }) => void): void;
-        offPrefetchStatusUpdated(listener: (event: { params: Protocol.Preload.PrefetchStatusUpdatedEvent }) => void): void;
-        oncePrefetchStatusUpdated(eventMatcher?: (event: { params: Protocol.Preload.PrefetchStatusUpdatedEvent }) => boolean): Promise<{ params: Protocol.Preload.PrefetchStatusUpdatedEvent }>;
-
-        /**
-         * Fired when a prerender attempt is updated.
-         */
-        onPrerenderStatusUpdated(listener: (event: { params: Protocol.Preload.PrerenderStatusUpdatedEvent }) => void): void;
-        offPrerenderStatusUpdated(listener: (event: { params: Protocol.Preload.PrerenderStatusUpdatedEvent }) => void): void;
-        oncePrerenderStatusUpdated(eventMatcher?: (event: { params: Protocol.Preload.PrerenderStatusUpdatedEvent }) => boolean): Promise<{ params: Protocol.Preload.PrerenderStatusUpdatedEvent }>;
-
-        /**
-         * Send a list of sources for all preloading attempts in a document.
-         */
-        onPreloadingAttemptSourcesUpdated(listener: (event: { params: Protocol.Preload.PreloadingAttemptSourcesUpdatedEvent }) => void): void;
-        offPreloadingAttemptSourcesUpdated(listener: (event: { params: Protocol.Preload.PreloadingAttemptSourcesUpdatedEvent }) => void): void;
-        oncePreloadingAttemptSourcesUpdated(eventMatcher?: (event: { params: Protocol.Preload.PreloadingAttemptSourcesUpdatedEvent }) => boolean): Promise<{ params: Protocol.Preload.PreloadingAttemptSourcesUpdatedEvent }>;
-
-    }
-
-    export interface FedCmApi {
-        enable(params: Protocol.FedCm.EnableRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        disable(): Promise<{id: number, result: void, sessionId: string}>;
-
-        selectAccount(params: Protocol.FedCm.SelectAccountRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        clickDialogButton(params: Protocol.FedCm.ClickDialogButtonRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        openUrl(params: Protocol.FedCm.OpenUrlRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        dismissDialog(params: Protocol.FedCm.DismissDialogRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Resets the cooldown time, if any, to allow the next FedCM call to show
-         * a dialog even if one was recently dismissed by the user.
-         */
-        resetCooldown(): Promise<{id: number, result: void, sessionId: string}>;
-
-        onDialogShown(listener: (event: { params: Protocol.FedCm.DialogShownEvent }) => void): void;
-        offDialogShown(listener: (event: { params: Protocol.FedCm.DialogShownEvent }) => void): void;
-        onceDialogShown(eventMatcher?: (event: { params: Protocol.FedCm.DialogShownEvent }) => boolean): Promise<{ params: Protocol.FedCm.DialogShownEvent }>;
-
-        /**
-         * Triggered when a dialog is closed, either by user action, JS abort,
-         * or a command below.
-         */
-        onDialogClosed(listener: (event: { params: Protocol.FedCm.DialogClosedEvent }) => void): void;
-        offDialogClosed(listener: (event: { params: Protocol.FedCm.DialogClosedEvent }) => void): void;
-        onceDialogClosed(eventMatcher?: (event: { params: Protocol.FedCm.DialogClosedEvent }) => boolean): Promise<{ params: Protocol.FedCm.DialogClosedEvent }>;
-
-    }
-
-    export interface PWAApi {
-        /**
-         * Returns the following OS state for the given manifest id.
-         */
-        getOsAppState(params: Protocol.PWA.GetOsAppStateRequest): Promise<{id: number, result: Protocol.PWA.GetOsAppStateResponse, sessionId: string}>;
-
-        /**
-         * Installs the given manifest identity, optionally using the given installUrlOrBundleUrl
-         * 
-         * IWA-specific install description:
-         * manifestId corresponds to isolated-app:// + web_package::SignedWebBundleId
-         * 
-         * File installation mode:
-         * The installUrlOrBundleUrl can be either file:// or http(s):// pointing
-         * to a signed web bundle (.swbn). In this case SignedWebBundleId must correspond to
-         * The .swbn file's signing key.
-         * 
-         * Dev proxy installation mode:
-         * installUrlOrBundleUrl must be http(s):// that serves dev mode IWA.
-         * web_package::SignedWebBundleId must be of type dev proxy.
-         * 
-         * The advantage of dev proxy mode is that all changes to IWA
-         * automatically will be reflected in the running app without
-         * reinstallation.
-         * 
-         * To generate bundle id for proxy mode:
-         * 1. Generate 32 random bytes.
-         * 2. Add a specific suffix 0x00 at the end.
-         * 3. Encode the entire sequence using Base32 without padding.
-         * 
-         * If Chrome is not in IWA dev
-         * mode, the installation will fail, regardless of the state of the allowlist.
-         */
-        install(params: Protocol.PWA.InstallRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Uninstalls the given manifest_id and closes any opened app windows.
-         */
-        uninstall(params: Protocol.PWA.UninstallRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Launches the installed web app, or an url in the same web app instead of the
-         * default start url if it is provided. Returns a page Target.TargetID which
-         * can be used to attach to via Target.attachToTarget or similar APIs.
-         */
-        launch(params: Protocol.PWA.LaunchRequest): Promise<{id: number, result: Protocol.PWA.LaunchResponse, sessionId: string}>;
-
-        /**
-         * Opens one or more local files from an installed web app identified by its
-         * manifestId. The web app needs to have file handlers registered to process
-         * the files. The API returns one or more page Target.TargetIDs which can be
-         * used to attach to via Target.attachToTarget or similar APIs.
-         * If some files in the parameters cannot be handled by the web app, they will
-         * be ignored. If none of the files can be handled, this API returns an error.
-         * If no files are provided as the parameter, this API also returns an error.
-         * 
-         * According to the definition of the file handlers in the manifest file, one
-         * Target.TargetID may represent a page handling one or more files. The order
-         * of the returned Target.TargetIDs is not guaranteed.
-         * 
-         * TODO(crbug.com/339454034): Check the existences of the input files.
-         */
-        launchFilesInApp(params: Protocol.PWA.LaunchFilesInAppRequest): Promise<{id: number, result: Protocol.PWA.LaunchFilesInAppResponse, sessionId: string}>;
-
-        /**
-         * Opens the current page in its web app identified by the manifest id, needs
-         * to be called on a page target. This function returns immediately without
-         * waiting for the app to finish loading.
-         */
-        openCurrentPageInApp(params: Protocol.PWA.OpenCurrentPageInAppRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Changes user settings of the web app identified by its manifestId. If the
-         * app was not installed, this command returns an error. Unset parameters will
-         * be ignored; unrecognized values will cause an error.
-         * 
-         * Unlike the ones defined in the manifest files of the web apps, these
-         * settings are provided by the browser and controlled by the users, they
-         * impact the way the browser handling the web apps.
-         * 
-         * See the comment of each parameter.
-         */
-        changeAppUserSettings(params: Protocol.PWA.ChangeAppUserSettingsRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-    }
-
-    export interface BluetoothEmulationApi {
-        /**
-         * Enable the BluetoothEmulation domain.
-         */
-        enable(params: Protocol.BluetoothEmulation.EnableRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Set the state of the simulated central.
-         */
-        setSimulatedCentralState(params: Protocol.BluetoothEmulation.SetSimulatedCentralStateRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Disable the BluetoothEmulation domain.
-         */
-        disable(): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Simulates a peripheral with |address|, |name| and |knownServiceUuids|
-         * that has already been connected to the system.
-         */
-        simulatePreconnectedPeripheral(params: Protocol.BluetoothEmulation.SimulatePreconnectedPeripheralRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Simulates an advertisement packet described in |entry| being received by
-         * the central.
-         */
-        simulateAdvertisement(params: Protocol.BluetoothEmulation.SimulateAdvertisementRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Simulates the response code from the peripheral with |address| for a
-         * GATT operation of |type|. The |code| value follows the HCI Error Codes from
-         * Bluetooth Core Specification Vol 2 Part D 1.3 List Of Error Codes.
-         */
-        simulateGATTOperationResponse(params: Protocol.BluetoothEmulation.SimulateGATTOperationResponseRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Simulates the response from the characteristic with |characteristicId| for a
-         * characteristic operation of |type|. The |code| value follows the Error
-         * Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.
-         * The |data| is expected to exist when simulating a successful read operation
-         * response.
-         */
-        simulateCharacteristicOperationResponse(params: Protocol.BluetoothEmulation.SimulateCharacteristicOperationResponseRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Simulates the response from the descriptor with |descriptorId| for a
-         * descriptor operation of |type|. The |code| value follows the Error
-         * Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.
-         * The |data| is expected to exist when simulating a successful read operation
-         * response.
-         */
-        simulateDescriptorOperationResponse(params: Protocol.BluetoothEmulation.SimulateDescriptorOperationResponseRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Adds a service with |serviceUuid| to the peripheral with |address|.
-         */
-        addService(params: Protocol.BluetoothEmulation.AddServiceRequest): Promise<{id: number, result: Protocol.BluetoothEmulation.AddServiceResponse, sessionId: string}>;
-
-        /**
-         * Removes the service respresented by |serviceId| from the simulated central.
-         */
-        removeService(params: Protocol.BluetoothEmulation.RemoveServiceRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Adds a characteristic with |characteristicUuid| and |properties| to the
-         * service represented by |serviceId|.
-         */
-        addCharacteristic(params: Protocol.BluetoothEmulation.AddCharacteristicRequest): Promise<{id: number, result: Protocol.BluetoothEmulation.AddCharacteristicResponse, sessionId: string}>;
-
-        /**
-         * Removes the characteristic respresented by |characteristicId| from the
-         * simulated central.
-         */
-        removeCharacteristic(params: Protocol.BluetoothEmulation.RemoveCharacteristicRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Adds a descriptor with |descriptorUuid| to the characteristic respresented
-         * by |characteristicId|.
-         */
-        addDescriptor(params: Protocol.BluetoothEmulation.AddDescriptorRequest): Promise<{id: number, result: Protocol.BluetoothEmulation.AddDescriptorResponse, sessionId: string}>;
-
-        /**
-         * Removes the descriptor with |descriptorId| from the simulated central.
-         */
-        removeDescriptor(params: Protocol.BluetoothEmulation.RemoveDescriptorRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Simulates a GATT disconnection from the peripheral with |address|.
-         */
-        simulateGATTDisconnection(params: Protocol.BluetoothEmulation.SimulateGATTDisconnectionRequest): Promise<{id: number, result: void, sessionId: string}>;
-
-        /**
-         * Event for when a GATT operation of |type| to the peripheral with |address|
-         * happened.
-         */
-        onGattOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.GattOperationReceivedEvent }) => void): void;
-        offGattOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.GattOperationReceivedEvent }) => void): void;
-        onceGattOperationReceived(eventMatcher?: (event: { params: Protocol.BluetoothEmulation.GattOperationReceivedEvent }) => boolean): Promise<{ params: Protocol.BluetoothEmulation.GattOperationReceivedEvent }>;
-
-        /**
-         * Event for when a characteristic operation of |type| to the characteristic
-         * respresented by |characteristicId| happened. |data| and |writeType| is
-         * expected to exist when |type| is write.
-         */
-        onCharacteristicOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.CharacteristicOperationReceivedEvent }) => void): void;
-        offCharacteristicOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.CharacteristicOperationReceivedEvent }) => void): void;
-        onceCharacteristicOperationReceived(eventMatcher?: (event: { params: Protocol.BluetoothEmulation.CharacteristicOperationReceivedEvent }) => boolean): Promise<{ params: Protocol.BluetoothEmulation.CharacteristicOperationReceivedEvent }>;
-
-        /**
-         * Event for when a descriptor operation of |type| to the descriptor
-         * respresented by |descriptorId| happened. |data| is expected to exist when
-         * |type| is write.
-         */
-        onDescriptorOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent }) => void): void;
-        offDescriptorOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent }) => void): void;
-        onceDescriptorOperationReceived(eventMatcher?: (event: { params: Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent }) => boolean): Promise<{ params: Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent }>;
-
-    }
 }
 
 export default ProtocolTestsProxyApi;