devtools-protocol 0.0.1498597 → 0.0.1501779

package/types/protocol-mapping.d.ts

@@ -16,6 +16,7 @@ export namespace ProtocolMapping {
         /**
          * Fired when breakpoint is resolved to an actual script and location.
          * Deprecated in favor of `resolvedBreakpoints` in the `scriptParsed` event.
+         * @deprecated
          */
         'Debugger.breakpointResolved': [Protocol.Debugger.BreakpointResolvedEvent];
         /**
@@ -58,10 +59,12 @@ export namespace ProtocolMapping {
          * `takePreciseCoverage` for the current isolate. May only be sent if precise code
          * coverage has been started. This event can be trigged by the embedder to, for example,
          * trigger collection of coverage data immediately at a certain point in time.
+         * @experimental
          */
         'Profiler.preciseCoverageDeltaUpdate': [Protocol.Profiler.PreciseCoverageDeltaUpdateEvent];
         /**
          * Notification is issued every time when binding is called.
+         * @experimental
          */
         'Runtime.bindingCalled': [Protocol.Runtime.BindingCalledEvent];
         /**
@@ -96,10 +99,12 @@ export namespace ProtocolMapping {
         /**
          * The loadComplete event mirrors the load complete event sent by the browser to assistive
          * technology when the web page has finished loading.
+         * @experimental
          */
         'Accessibility.loadComplete': [Protocol.Accessibility.LoadCompleteEvent];
         /**
          * The nodesUpdated event is sent every time a previously requested node has changed the in tree.
+         * @experimental
          */
         'Accessibility.nodesUpdated': [Protocol.Accessibility.NodesUpdatedEvent];
         /**
@@ -132,12 +137,31 @@ export namespace ProtocolMapping {
          * events afterwards if enabled and recording.
          */
         'BackgroundService.backgroundServiceEventReceived': [Protocol.BackgroundService.BackgroundServiceEventReceivedEvent];
+        /**
+         * Event for when a GATT operation of |type| to the peripheral with |address|
+         * happened.
+         */
+        'BluetoothEmulation.gattOperationReceived': [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.
+         */
+        'BluetoothEmulation.characteristicOperationReceived': [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.
+         */
+        'BluetoothEmulation.descriptorOperationReceived': [Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent];
         /**
          * Fired when page is about to start a download.
+         * @experimental
          */
         'Browser.downloadWillBegin': [Protocol.Browser.DownloadWillBeginEvent];
         /**
          * Fired when download makes progress. Last call has |done| == true.
+         * @experimental
          */
         'Browser.downloadProgress': [Protocol.Browser.DownloadProgressEvent];
         /**
@@ -162,6 +186,9 @@ export namespace ProtocolMapping {
          * Fired whenever an active document stylesheet is removed.
          */
         'CSS.styleSheetRemoved': [Protocol.CSS.StyleSheetRemovedEvent];
+        /**
+         * @experimental
+         */
         'CSS.computedStyleUpdated': [Protocol.CSS.ComputedStyleUpdatedEvent];
         /**
          * This is fired whenever the list of available sinks changes. A sink is a
@@ -199,6 +226,7 @@ export namespace ProtocolMapping {
         'DOM.childNodeRemoved': [Protocol.DOM.ChildNodeRemovedEvent];
         /**
          * Called when distribution is changed.
+         * @experimental
          */
         'DOM.distributedNodesUpdated': [Protocol.DOM.DistributedNodesUpdatedEvent];
         /**
@@ -207,22 +235,27 @@ export namespace ProtocolMapping {
         'DOM.documentUpdated': [];
         /**
          * Fired when `Element`'s inline style is modified via a CSS property modification.
+         * @experimental
          */
         'DOM.inlineStyleInvalidated': [Protocol.DOM.InlineStyleInvalidatedEvent];
         /**
          * Called when a pseudo element is added to an element.
+         * @experimental
          */
         'DOM.pseudoElementAdded': [Protocol.DOM.PseudoElementAddedEvent];
         /**
          * Called when top layer elements are changed.
+         * @experimental
          */
         'DOM.topLayerElementsUpdated': [];
         /**
          * Fired when a node's scrollability state changes.
+         * @experimental
          */
         'DOM.scrollableFlagUpdated': [Protocol.DOM.ScrollableFlagUpdatedEvent];
         /**
          * Called when a pseudo element is removed from an element.
+         * @experimental
          */
         'DOM.pseudoElementRemoved': [Protocol.DOM.PseudoElementRemovedEvent];
         /**
@@ -232,23 +265,57 @@ export namespace ProtocolMapping {
         'DOM.setChildNodes': [Protocol.DOM.SetChildNodesEvent];
         /**
          * Called when shadow root is popped from the element.
+         * @experimental
          */
         'DOM.shadowRootPopped': [Protocol.DOM.ShadowRootPoppedEvent];
         /**
          * Called when shadow root is pushed into the element.
+         * @experimental
          */
         'DOM.shadowRootPushed': [Protocol.DOM.ShadowRootPushedEvent];
         'DOMStorage.domStorageItemAdded': [Protocol.DOMStorage.DomStorageItemAddedEvent];
         'DOMStorage.domStorageItemRemoved': [Protocol.DOMStorage.DomStorageItemRemovedEvent];
         'DOMStorage.domStorageItemUpdated': [Protocol.DOMStorage.DomStorageItemUpdatedEvent];
         'DOMStorage.domStorageItemsCleared': [Protocol.DOMStorage.DomStorageItemsClearedEvent];
+        /**
+         * A device request opened a user prompt to select a device. Respond with the
+         * selectPrompt or cancelPrompt command.
+         */
+        'DeviceAccess.deviceRequestPrompted': [Protocol.DeviceAccess.DeviceRequestPromptedEvent];
         /**
          * Notification sent after the virtual time budget for the current VirtualTimePolicy has run out.
+         * @experimental
          */
         'Emulation.virtualTimeBudgetExpired': [];
+        'FedCm.dialogShown': [Protocol.FedCm.DialogShownEvent];
+        /**
+         * Triggered when a dialog is closed, either by user action, JS abort,
+         * or a command below.
+         */
+        'FedCm.dialogClosed': [Protocol.FedCm.DialogClosedEvent];
+        /**
+         * 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.
+         */
+        'Fetch.requestPaused': [Protocol.Fetch.RequestPausedEvent];
+        /**
+         * Issued when the domain is enabled with handleAuthRequests set to true.
+         * The request is paused until client responds with continueWithAuth.
+         */
+        'Fetch.authRequired': [Protocol.Fetch.AuthRequiredEvent];
         /**
          * Emitted only when `Input.setInterceptDrags` is enabled. Use this data with `Input.dispatchDragEvent` to
          * restore normal drag and drop behavior.
+         * @experimental
          */
         'Input.dragIntercepted': [Protocol.Input.DragInterceptedEvent];
         /**
@@ -269,6 +336,30 @@ export namespace ProtocolMapping {
          * Issued when new message was logged.
          */
         'Log.entryAdded': [Protocol.Log.EntryAddedEvent];
+        /**
+         * This can be called multiple times, and can be used to set / override /
+         * remove player properties. A null propValue indicates removal.
+         */
+        'Media.playerPropertiesChanged': [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.
+         */
+        'Media.playerEventsAdded': [Protocol.Media.PlayerEventsAddedEvent];
+        /**
+         * Send a list of any messages that need to be delivered.
+         */
+        'Media.playerMessagesLogged': [Protocol.Media.PlayerMessagesLoggedEvent];
+        /**
+         * Send a list of any errors that need to be delivered.
+         */
+        'Media.playerErrorsRaised': [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.
+         */
+        'Media.playersCreated': [Protocol.Media.PlayersCreatedEvent];
         /**
          * Fired when data chunk was received over the network.
          */
@@ -289,6 +380,8 @@ export namespace ProtocolMapping {
          * Details of an intercepted HTTP request, which must be either allowed, blocked, modified or
          * mocked.
          * Deprecated, use Fetch.requestPaused instead.
+         * @deprecated
+         * @experimental
          */
         'Network.requestIntercepted': [Protocol.Network.RequestInterceptedEvent];
         /**
@@ -301,10 +394,12 @@ export namespace ProtocolMapping {
         'Network.requestWillBeSent': [Protocol.Network.RequestWillBeSentEvent];
         /**
          * Fired when resource loading priority is changed
+         * @experimental
          */
         'Network.resourceChangedPriority': [Protocol.Network.ResourceChangedPriorityEvent];
         /**
          * Fired when a signed exchange was received over the network
+         * @experimental
          */
         'Network.signedExchangeReceived': [Protocol.Network.SignedExchangeReceivedEvent];
         /**
@@ -353,50 +448,62 @@ export namespace ProtocolMapping {
         'Network.webTransportClosed': [Protocol.Network.WebTransportClosedEvent];
         /**
          * Fired upon direct_socket.TCPSocket creation.
+         * @experimental
          */
         'Network.directTCPSocketCreated': [Protocol.Network.DirectTCPSocketCreatedEvent];
         /**
          * Fired when direct_socket.TCPSocket connection is opened.
+         * @experimental
          */
         'Network.directTCPSocketOpened': [Protocol.Network.DirectTCPSocketOpenedEvent];
         /**
          * Fired when direct_socket.TCPSocket is aborted.
+         * @experimental
          */
         'Network.directTCPSocketAborted': [Protocol.Network.DirectTCPSocketAbortedEvent];
         /**
          * Fired when direct_socket.TCPSocket is closed.
+         * @experimental
          */
         'Network.directTCPSocketClosed': [Protocol.Network.DirectTCPSocketClosedEvent];
         /**
          * Fired when data is sent to tcp direct socket stream.
+         * @experimental
          */
         'Network.directTCPSocketChunkSent': [Protocol.Network.DirectTCPSocketChunkSentEvent];
         /**
          * Fired when data is received from tcp direct socket stream.
+         * @experimental
          */
         'Network.directTCPSocketChunkReceived': [Protocol.Network.DirectTCPSocketChunkReceivedEvent];
         /**
          * Fired upon direct_socket.UDPSocket creation.
+         * @experimental
          */
         'Network.directUDPSocketCreated': [Protocol.Network.DirectUDPSocketCreatedEvent];
         /**
          * Fired when direct_socket.UDPSocket connection is opened.
+         * @experimental
          */
         'Network.directUDPSocketOpened': [Protocol.Network.DirectUDPSocketOpenedEvent];
         /**
          * Fired when direct_socket.UDPSocket is aborted.
+         * @experimental
          */
         'Network.directUDPSocketAborted': [Protocol.Network.DirectUDPSocketAbortedEvent];
         /**
          * Fired when direct_socket.UDPSocket is closed.
+         * @experimental
          */
         'Network.directUDPSocketClosed': [Protocol.Network.DirectUDPSocketClosedEvent];
         /**
          * Fired when message is sent to udp direct socket stream.
+         * @experimental
          */
         'Network.directUDPSocketChunkSent': [Protocol.Network.DirectUDPSocketChunkSentEvent];
         /**
          * Fired when message is received from udp direct socket stream.
+         * @experimental
          */
         'Network.directUDPSocketChunkReceived': [Protocol.Network.DirectUDPSocketChunkReceivedEvent];
         /**
@@ -404,18 +511,21 @@ export namespace ProtocolMapping {
          * network stack. Not every requestWillBeSent event will have an additional
          * requestWillBeSentExtraInfo fired for it, and there is no guarantee whether requestWillBeSent
          * or requestWillBeSentExtraInfo will be fired first for the same request.
+         * @experimental
          */
         'Network.requestWillBeSentExtraInfo': [Protocol.Network.RequestWillBeSentExtraInfoEvent];
         /**
          * Fired when additional information about a responseReceived event is available from the network
          * stack. Not every responseReceived event will have an additional responseReceivedExtraInfo for
          * it, and responseReceivedExtraInfo may be fired before or after responseReceived.
+         * @experimental
          */
         'Network.responseReceivedExtraInfo': [Protocol.Network.ResponseReceivedExtraInfoEvent];
         /**
          * Fired when 103 Early Hints headers is received in addition to the common response.
          * Not every responseReceived event will have an responseReceivedEarlyHints fired.
          * Only one responseReceivedEarlyHints may be fired for eached responseReceived event.
+         * @experimental
          */
         'Network.responseReceivedEarlyHints': [Protocol.Network.ResponseReceivedEarlyHintsEvent];
         /**
@@ -423,36 +533,49 @@ export namespace ProtocolMapping {
          * the type of the operation and whether the operation succeeded or
          * failed, the event is fired before the corresponding request was sent
          * or after the response was received.
+         * @experimental
          */
         'Network.trustTokenOperationDone': [Protocol.Network.TrustTokenOperationDoneEvent];
         /**
          * Fired once security policy has been updated.
+         * @experimental
          */
         'Network.policyUpdated': [];
         /**
          * Fired once when parsing the .wbn file has succeeded.
          * The event contains the information about the web bundle contents.
+         * @experimental
          */
         'Network.subresourceWebBundleMetadataReceived': [Protocol.Network.SubresourceWebBundleMetadataReceivedEvent];
         /**
          * Fired once when parsing the .wbn file has failed.
+         * @experimental
          */
         'Network.subresourceWebBundleMetadataError': [Protocol.Network.SubresourceWebBundleMetadataErrorEvent];
         /**
          * Fired when handling requests for resources within a .wbn file.
          * Note: this will only be fired for resources that are requested by the webpage.
+         * @experimental
          */
         'Network.subresourceWebBundleInnerResponseParsed': [Protocol.Network.SubresourceWebBundleInnerResponseParsedEvent];
         /**
          * Fired when request for resources within a .wbn file failed.
+         * @experimental
          */
         'Network.subresourceWebBundleInnerResponseError': [Protocol.Network.SubresourceWebBundleInnerResponseErrorEvent];
         /**
          * Is sent whenever a new report is added.
          * And after 'enableReportingApi' for all existing reports.
+         * @experimental
          */
         'Network.reportingApiReportAdded': [Protocol.Network.ReportingApiReportAddedEvent];
+        /**
+         * @experimental
+         */
         'Network.reportingApiReportUpdated': [Protocol.Network.ReportingApiReportUpdatedEvent];
+        /**
+         * @experimental
+         */
         'Network.reportingApiEndpointsChangedForOrigin': [Protocol.Network.ReportingApiEndpointsChangedForOriginEvent];
         /**
          * Fired when the node should be inspected. This happens after call to `setInspectMode` or when
@@ -482,6 +605,7 @@ export namespace ProtocolMapping {
         'Page.frameAttached': [Protocol.Page.FrameAttachedEvent];
         /**
          * Fired when frame no longer has a scheduled navigation.
+         * @deprecated
          */
         'Page.frameClearedScheduledNavigation': [Protocol.Page.FrameClearedScheduledNavigationEvent];
         /**
@@ -491,6 +615,7 @@ export namespace ProtocolMapping {
         /**
          * Fired before frame subtree is detached. Emitted before any frame of the
          * subtree is actually detached.
+         * @experimental
          */
         'Page.frameSubtreeWillBeDetached': [Protocol.Page.FrameSubtreeWillBeDetachedEvent];
         /**
@@ -499,8 +624,12 @@ export namespace ProtocolMapping {
         'Page.frameNavigated': [Protocol.Page.FrameNavigatedEvent];
         /**
          * Fired when opening document to write to.
+         * @experimental
          */
         'Page.documentOpened': [Protocol.Page.DocumentOpenedEvent];
+        /**
+         * @experimental
+         */
         'Page.frameResized': [];
         /**
          * Fired when a navigation starts. This event is fired for both
@@ -510,33 +639,42 @@ export namespace ProtocolMapping {
          * can be fired for a single navigation, for example, when a same-document
          * navigation becomes a cross-document navigation (such as in the case of a
          * frameset).
+         * @experimental
          */
         'Page.frameStartedNavigating': [Protocol.Page.FrameStartedNavigatingEvent];
         /**
          * Fired when a renderer-initiated navigation is requested.
          * Navigation may still be cancelled after the event is issued.
+         * @experimental
          */
         'Page.frameRequestedNavigation': [Protocol.Page.FrameRequestedNavigationEvent];
         /**
          * Fired when frame schedules a potential navigation.
+         * @deprecated
          */
         'Page.frameScheduledNavigation': [Protocol.Page.FrameScheduledNavigationEvent];
         /**
          * Fired when frame has started loading.
+         * @experimental
          */
         'Page.frameStartedLoading': [Protocol.Page.FrameStartedLoadingEvent];
         /**
          * Fired when frame has stopped loading.
+         * @experimental
          */
         'Page.frameStoppedLoading': [Protocol.Page.FrameStoppedLoadingEvent];
         /**
          * Fired when page is about to start a download.
          * Deprecated. Use Browser.downloadWillBegin instead.
+         * @deprecated
+         * @experimental
          */
         'Page.downloadWillBegin': [Protocol.Page.DownloadWillBeginEvent];
         /**
          * Fired when download makes progress. Last call has |done| == true.
          * Deprecated. Use Browser.downloadProgress instead.
+         * @deprecated
+         * @experimental
          */
         'Page.downloadProgress': [Protocol.Page.DownloadProgressEvent];
         /**
@@ -567,19 +705,23 @@ export namespace ProtocolMapping {
          * not assume any ordering with the Page.frameNavigated event. This event is fired only for
          * main-frame history navigation where the document changes (non-same-document navigations),
          * when bfcache navigation fails.
+         * @experimental
          */
         'Page.backForwardCacheNotUsed': [Protocol.Page.BackForwardCacheNotUsedEvent];
         'Page.loadEventFired': [Protocol.Page.LoadEventFiredEvent];
         /**
          * Fired when same-document navigation happens, e.g. due to history API usage or anchor navigation.
+         * @experimental
          */
         'Page.navigatedWithinDocument': [Protocol.Page.NavigatedWithinDocumentEvent];
         /**
          * Compressed image data requested by the `startScreencast`.
+         * @experimental
          */
         'Page.screencastFrame': [Protocol.Page.ScreencastFrameEvent];
         /**
          * Fired when the page with currently enabled screencast was shown or hidden `.
+         * @experimental
          */
         'Page.screencastVisibilityChanged': [Protocol.Page.ScreencastVisibilityChangedEvent];
         /**
@@ -589,6 +731,7 @@ export namespace ProtocolMapping {
         'Page.windowOpen': [Protocol.Page.WindowOpenEvent];
         /**
          * Issued for every compilation cache generated.
+         * @experimental
          */
         'Page.compilationCacheProduced': [Protocol.Page.CompilationCacheProducedEvent];
         /**
@@ -599,19 +742,43 @@ export namespace ProtocolMapping {
          * Sent when a performance timeline event is added. See reportPerformanceTimeline method.
          */
         'PerformanceTimeline.timelineEventAdded': [Protocol.PerformanceTimeline.TimelineEventAddedEvent];
+        /**
+         * Upsert. Currently, it is only emitted when a rule set added.
+         */
+        'Preload.ruleSetUpdated': [Protocol.Preload.RuleSetUpdatedEvent];
+        'Preload.ruleSetRemoved': [Protocol.Preload.RuleSetRemovedEvent];
+        /**
+         * Fired when a preload enabled state is updated.
+         */
+        'Preload.preloadEnabledStateUpdated': [Protocol.Preload.PreloadEnabledStateUpdatedEvent];
+        /**
+         * Fired when a prefetch attempt is updated.
+         */
+        'Preload.prefetchStatusUpdated': [Protocol.Preload.PrefetchStatusUpdatedEvent];
+        /**
+         * Fired when a prerender attempt is updated.
+         */
+        'Preload.prerenderStatusUpdated': [Protocol.Preload.PrerenderStatusUpdatedEvent];
+        /**
+         * Send a list of sources for all preloading attempts in a document.
+         */
+        'Preload.preloadingAttemptSourcesUpdated': [Protocol.Preload.PreloadingAttemptSourcesUpdatedEvent];
         /**
          * There is a certificate error. If overriding certificate errors is enabled, then it should be
          * handled with the `handleCertificateError` command. Note: this event does not fire if the
          * certificate error has been allowed internally. Only one client per target should override
          * certificate errors at the same time.
+         * @deprecated
          */
         'Security.certificateError': [Protocol.Security.CertificateErrorEvent];
         /**
          * The security state of the page changed.
+         * @experimental
          */
         'Security.visibleSecurityStateChanged': [Protocol.Security.VisibleSecurityStateChangedEvent];
         /**
          * The security state of the page changed. No longer being sent.
+         * @deprecated
          */
         'Security.securityStateChanged': [Protocol.Security.SecurityStateChangedEvent];
         'ServiceWorker.workerErrorReported': [Protocol.ServiceWorker.WorkerErrorReportedEvent];
@@ -662,17 +829,31 @@ export namespace ProtocolMapping {
         'Storage.sharedStorageWorkletOperationExecutionFinished': [Protocol.Storage.SharedStorageWorkletOperationExecutionFinishedEvent];
         'Storage.storageBucketCreatedOrUpdated': [Protocol.Storage.StorageBucketCreatedOrUpdatedEvent];
         'Storage.storageBucketDeleted': [Protocol.Storage.StorageBucketDeletedEvent];
+        /**
+         * @experimental
+         */
         'Storage.attributionReportingSourceRegistered': [Protocol.Storage.AttributionReportingSourceRegisteredEvent];
+        /**
+         * @experimental
+         */
         'Storage.attributionReportingTriggerRegistered': [Protocol.Storage.AttributionReportingTriggerRegisteredEvent];
+        /**
+         * @experimental
+         */
         'Storage.attributionReportingReportSent': [Protocol.Storage.AttributionReportingReportSentEvent];
+        /**
+         * @experimental
+         */
         'Storage.attributionReportingVerboseDebugReportSent': [Protocol.Storage.AttributionReportingVerboseDebugReportSentEvent];
         /**
          * Issued when attached to target because of auto-attach or `attachToTarget` command.
+         * @experimental
          */
         'Target.attachedToTarget': [Protocol.Target.AttachedToTargetEvent];
         /**
          * Issued when detached from target for any reason (including `detachFromTarget` command). Can be
          * issued multiple times per target if multiple sessions have been attached to it.
+         * @experimental
          */
         'Target.detachedFromTarget': [Protocol.Target.DetachedFromTargetEvent];
         /**
@@ -701,10 +882,14 @@ export namespace ProtocolMapping {
          * Informs that port was successfully bound and got a specified connection id.
          */
         'Tethering.accepted': [Protocol.Tethering.AcceptedEvent];
+        /**
+         * @experimental
+         */
         'Tracing.bufferUsage': [Protocol.Tracing.BufferUsageEvent];
         /**
          * Contains a bucket of collected trace events. When tracing is stopped collected events will be
          * sent as a sequence of dataCollected events followed by tracingComplete event.
+         * @experimental
          */
         'Tracing.dataCollected': [Protocol.Tracing.DataCollectedEvent];
         /**
@@ -712,25 +897,6 @@ export namespace ProtocolMapping {
          * delivered via dataCollected events.
          */
         'Tracing.tracingComplete': [Protocol.Tracing.TracingCompleteEvent];
-        /**
-         * 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.
-         */
-        'Fetch.requestPaused': [Protocol.Fetch.RequestPausedEvent];
-        /**
-         * Issued when the domain is enabled with handleAuthRequests set to true.
-         * The request is paused until client responds with continueWithAuth.
-         */
-        'Fetch.authRequired': [Protocol.Fetch.AuthRequiredEvent];
         /**
          * Notifies that a new BaseAudioContext has been created.
          */
@@ -801,79 +967,6 @@ export namespace ProtocolMapping {
          * Triggered when a credential is used in a webauthn assertion.
          */
         'WebAuthn.credentialAsserted': [Protocol.WebAuthn.CredentialAssertedEvent];
-        /**
-         * This can be called multiple times, and can be used to set / override /
-         * remove player properties. A null propValue indicates removal.
-         */
-        'Media.playerPropertiesChanged': [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.
-         */
-        'Media.playerEventsAdded': [Protocol.Media.PlayerEventsAddedEvent];
-        /**
-         * Send a list of any messages that need to be delivered.
-         */
-        'Media.playerMessagesLogged': [Protocol.Media.PlayerMessagesLoggedEvent];
-        /**
-         * Send a list of any errors that need to be delivered.
-         */
-        'Media.playerErrorsRaised': [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.
-         */
-        'Media.playersCreated': [Protocol.Media.PlayersCreatedEvent];
-        /**
-         * A device request opened a user prompt to select a device. Respond with the
-         * selectPrompt or cancelPrompt command.
-         */
-        'DeviceAccess.deviceRequestPrompted': [Protocol.DeviceAccess.DeviceRequestPromptedEvent];
-        /**
-         * Upsert. Currently, it is only emitted when a rule set added.
-         */
-        'Preload.ruleSetUpdated': [Protocol.Preload.RuleSetUpdatedEvent];
-        'Preload.ruleSetRemoved': [Protocol.Preload.RuleSetRemovedEvent];
-        /**
-         * Fired when a preload enabled state is updated.
-         */
-        'Preload.preloadEnabledStateUpdated': [Protocol.Preload.PreloadEnabledStateUpdatedEvent];
-        /**
-         * Fired when a prefetch attempt is updated.
-         */
-        'Preload.prefetchStatusUpdated': [Protocol.Preload.PrefetchStatusUpdatedEvent];
-        /**
-         * Fired when a prerender attempt is updated.
-         */
-        'Preload.prerenderStatusUpdated': [Protocol.Preload.PrerenderStatusUpdatedEvent];
-        /**
-         * Send a list of sources for all preloading attempts in a document.
-         */
-        'Preload.preloadingAttemptSourcesUpdated': [Protocol.Preload.PreloadingAttemptSourcesUpdatedEvent];
-        'FedCm.dialogShown': [Protocol.FedCm.DialogShownEvent];
-        /**
-         * Triggered when a dialog is closed, either by user action, JS abort,
-         * or a command below.
-         */
-        'FedCm.dialogClosed': [Protocol.FedCm.DialogClosedEvent];
-        /**
-         * Event for when a GATT operation of |type| to the peripheral with |address|
-         * happened.
-         */
-        'BluetoothEmulation.gattOperationReceived': [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.
-         */
-        'BluetoothEmulation.characteristicOperationReceived': [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.
-         */
-        'BluetoothEmulation.descriptorOperationReceived': [Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent];
     }
 
     export interface Commands {
@@ -943,6 +1036,9 @@ export namespace ProtocolMapping {
             paramsType: [Protocol.Debugger.GetScriptSourceRequest];
             returnType: Protocol.Debugger.GetScriptSourceResponse;
         };
+        /**
+         * @experimental
+         */
         'Debugger.disassembleWasmModule': {
             paramsType: [Protocol.Debugger.DisassembleWasmModuleRequest];
             returnType: Protocol.Debugger.DisassembleWasmModuleResponse;
@@ -952,6 +1048,7 @@ export namespace ProtocolMapping {
          * stream. If disassembly is complete, this API will invalidate the streamId
          * and return an empty chunk. Any subsequent calls for the now invalid stream
          * will return errors.
+         * @experimental
          */
         'Debugger.nextWasmDisassemblyChunk': {
             paramsType: [Protocol.Debugger.NextWasmDisassemblyChunkRequest];
@@ -959,6 +1056,7 @@ export namespace ProtocolMapping {
         };
         /**
          * This command is deprecated. Use getScriptSource instead.
+         * @deprecated
          */
         'Debugger.getWasmBytecode': {
             paramsType: [Protocol.Debugger.GetWasmBytecodeRequest];
@@ -966,6 +1064,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Returns stack trace with given `stackTraceId`.
+         * @experimental
          */
         'Debugger.getStackTrace': {
             paramsType: [Protocol.Debugger.GetStackTraceRequest];
@@ -978,6 +1077,10 @@ export namespace ProtocolMapping {
             paramsType: [];
             returnType: void;
         };
+        /**
+         * @deprecated
+         * @experimental
+         */
         'Debugger.pauseOnAsyncCall': {
             paramsType: [Protocol.Debugger.PauseOnAsyncCallRequest];
             returnType: void;
@@ -1033,6 +1136,7 @@ export namespace ProtocolMapping {
          * Replace previous blackbox execution contexts with passed ones. Forces backend to skip
          * stepping/pausing in scripts in these execution contexts. VM will try to leave blackboxed script by
          * performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
+         * @experimental
          */
         'Debugger.setBlackboxExecutionContexts': {
             paramsType: [Protocol.Debugger.SetBlackboxExecutionContextsRequest];
@@ -1042,6 +1146,7 @@ export namespace ProtocolMapping {
          * Replace previous blackbox patterns with passed ones. Forces backend to skip stepping/pausing in
          * scripts with url matching one of the patterns. VM will try to leave blackboxed script by
          * performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
+         * @experimental
          */
         'Debugger.setBlackboxPatterns': {
             paramsType: [Protocol.Debugger.SetBlackboxPatternsRequest];
@@ -1052,6 +1157,7 @@ export namespace ProtocolMapping {
          * scripts by performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
          * Positions array contains positions where blackbox state is changed. First interval isn't
          * blackboxed. Array should be sorted.
+         * @experimental
          */
         'Debugger.setBlackboxedRanges': {
             paramsType: [Protocol.Debugger.SetBlackboxedRangesRequest];
@@ -1085,6 +1191,7 @@ export namespace ProtocolMapping {
          * Sets JavaScript breakpoint before each call to the given function.
          * If another function was created from the same source as a given one,
          * calling it will also trigger the breakpoint.
+         * @experimental
          */
         'Debugger.setBreakpointOnFunctionCall': {
             paramsType: [Protocol.Debugger.SetBreakpointOnFunctionCallRequest];
@@ -1107,6 +1214,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Changes return value in top frame. Available only at return break position.
+         * @experimental
          */
         'Debugger.setReturnValue': {
             paramsType: [Protocol.Debugger.SetReturnValueRequest];
@@ -1323,6 +1431,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Returns the isolate id.
+         * @experimental
          */
         'Runtime.getIsolateId': {
             paramsType: [];
@@ -1331,6 +1440,7 @@ export namespace ProtocolMapping {
         /**
          * Returns the JavaScript heap usage.
          * It is the total usage of the corresponding isolate not scoped to a particular Runtime.
+         * @experimental
          */
         'Runtime.getHeapUsage': {
             paramsType: [];
@@ -1390,10 +1500,16 @@ export namespace ProtocolMapping {
             paramsType: [Protocol.Runtime.SetAsyncCallStackDepthRequest];
             returnType: void;
         };
+        /**
+         * @experimental
+         */
         'Runtime.setCustomObjectFormatterEnabled': {
             paramsType: [Protocol.Runtime.SetCustomObjectFormatterEnabledRequest];
             returnType: void;
         };
+        /**
+         * @experimental
+         */
         'Runtime.setMaxCallStackSizeToCapture': {
             paramsType: [Protocol.Runtime.SetMaxCallStackSizeToCaptureRequest];
             returnType: void;
@@ -1401,6 +1517,7 @@ export namespace ProtocolMapping {
         /**
          * Terminate current or next JavaScript execution.
          * Will cancel the termination when the outer-most script execution ends.
+         * @experimental
          */
         'Runtime.terminateExecution': {
             paramsType: [];
@@ -1432,6 +1549,7 @@ export namespace ProtocolMapping {
          * Note that the stackTrace portion of the resulting exceptionDetails will
          * only be populated if the Runtime domain was enabled at the time when the
          * Error was thrown.
+         * @experimental
          */
         'Runtime.getExceptionDetails': {
             paramsType: [Protocol.Runtime.GetExceptionDetailsRequest];
@@ -1461,6 +1579,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Fetches the accessibility node and partial accessibility tree for this DOM node, if it exists.
+         * @experimental
          */
         'Accessibility.getPartialAXTree': {
             paramsType: [Protocol.Accessibility.GetPartialAXTreeRequest?];
@@ -1468,6 +1587,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Fetches the entire accessibility tree for the root Document
+         * @experimental
          */
         'Accessibility.getFullAXTree': {
             paramsType: [Protocol.Accessibility.GetFullAXTreeRequest?];
@@ -1476,6 +1596,7 @@ export namespace ProtocolMapping {
         /**
          * Fetches the root node.
          * Requires `enable()` to have been called previously.
+         * @experimental
          */
         'Accessibility.getRootAXNode': {
             paramsType: [Protocol.Accessibility.GetRootAXNodeRequest?];
@@ -1484,6 +1605,7 @@ export namespace ProtocolMapping {
         /**
          * Fetches a node and all ancestors up to and including the root.
          * Requires `enable()` to have been called previously.
+         * @experimental
          */
         'Accessibility.getAXNodeAndAncestors': {
             paramsType: [Protocol.Accessibility.GetAXNodeAndAncestorsRequest?];
@@ -1492,6 +1614,7 @@ export namespace ProtocolMapping {
         /**
          * Fetches a particular accessibility node by AXNodeId.
          * Requires `enable()` to have been called previously.
+         * @experimental
          */
         'Accessibility.getChildAXNodes': {
             paramsType: [Protocol.Accessibility.GetChildAXNodesRequest];
@@ -1503,6 +1626,7 @@ export namespace ProtocolMapping {
          * ignored for accessibility, and returns those that match the specified name and role. If no DOM
          * node is specified, or the DOM node does not exist, the command returns an error. If neither
          * `accessibleName` or `role` is specified, it returns all the accessibility nodes in the subtree.
+         * @experimental
          */
         'Accessibility.queryAXTree': {
             paramsType: [Protocol.Accessibility.QueryAXTreeRequest?];
@@ -1618,114 +1742,185 @@ export namespace ProtocolMapping {
             returnType: Protocol.Audits.CheckFormsIssuesResponse;
         };
         /**
-         * 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.
+         * Trigger autofill on a form identified by the fieldId.
+         * If the field and related form cannot be autofilled, returns an error.
          */
-        'Extensions.loadUnpacked': {
-            paramsType: [Protocol.Extensions.LoadUnpackedRequest];
-            returnType: Protocol.Extensions.LoadUnpackedResponse;
+        'Autofill.trigger': {
+            paramsType: [Protocol.Autofill.TriggerRequest];
+            returnType: void;
         };
         /**
-         * 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.
+         * Set addresses so that developers can verify their forms implementation.
          */
-        'Extensions.uninstall': {
-            paramsType: [Protocol.Extensions.UninstallRequest];
+        'Autofill.setAddresses': {
+            paramsType: [Protocol.Autofill.SetAddressesRequest];
             returnType: void;
         };
         /**
-         * Gets data from extension storage in the given `storageArea`. If `keys` is
-         * specified, these are used to filter the result.
+         * Disables autofill domain notifications.
          */
-        'Extensions.getStorageItems': {
-            paramsType: [Protocol.Extensions.GetStorageItemsRequest];
-            returnType: Protocol.Extensions.GetStorageItemsResponse;
+        'Autofill.disable': {
+            paramsType: [];
+            returnType: void;
         };
         /**
-         * Removes `keys` from extension storage in the given `storageArea`.
+         * Enables autofill domain notifications.
          */
-        'Extensions.removeStorageItems': {
-            paramsType: [Protocol.Extensions.RemoveStorageItemsRequest];
+        'Autofill.enable': {
+            paramsType: [];
             returnType: void;
         };
         /**
-         * Clears extension storage in the given `storageArea`.
+         * Enables event updates for the service.
          */
-        'Extensions.clearStorageItems': {
-            paramsType: [Protocol.Extensions.ClearStorageItemsRequest];
+        'BackgroundService.startObserving': {
+            paramsType: [Protocol.BackgroundService.StartObservingRequest];
             returnType: void;
         };
         /**
-         * Sets `values` in extension storage in the given `storageArea`. The provided `values`
-         * will be merged with existing values in the storage area.
+         * Disables event updates for the service.
          */
-        'Extensions.setStorageItems': {
-            paramsType: [Protocol.Extensions.SetStorageItemsRequest];
+        'BackgroundService.stopObserving': {
+            paramsType: [Protocol.BackgroundService.StopObservingRequest];
             returnType: void;
         };
         /**
-         * Trigger autofill on a form identified by the fieldId.
-         * If the field and related form cannot be autofilled, returns an error.
+         * Set the recording state for the service.
          */
-        'Autofill.trigger': {
-            paramsType: [Protocol.Autofill.TriggerRequest];
+        'BackgroundService.setRecording': {
+            paramsType: [Protocol.BackgroundService.SetRecordingRequest];
             returnType: void;
         };
         /**
-         * Set addresses so that developers can verify their forms implementation.
+         * Clears all stored data for the service.
          */
-        'Autofill.setAddresses': {
-            paramsType: [Protocol.Autofill.SetAddressesRequest];
+        'BackgroundService.clearEvents': {
+            paramsType: [Protocol.BackgroundService.ClearEventsRequest];
             returnType: void;
         };
         /**
-         * Disables autofill domain notifications.
+         * Enable the BluetoothEmulation domain.
          */
-        'Autofill.disable': {
-            paramsType: [];
+        'BluetoothEmulation.enable': {
+            paramsType: [Protocol.BluetoothEmulation.EnableRequest];
             returnType: void;
         };
         /**
-         * Enables autofill domain notifications.
+         * Set the state of the simulated central.
          */
-        'Autofill.enable': {
+        'BluetoothEmulation.setSimulatedCentralState': {
+            paramsType: [Protocol.BluetoothEmulation.SetSimulatedCentralStateRequest];
+            returnType: void;
+        };
+        /**
+         * Disable the BluetoothEmulation domain.
+         */
+        'BluetoothEmulation.disable': {
             paramsType: [];
             returnType: void;
         };
         /**
-         * Enables event updates for the service.
+         * Simulates a peripheral with |address|, |name| and |knownServiceUuids|
+         * that has already been connected to the system.
          */
-        'BackgroundService.startObserving': {
-            paramsType: [Protocol.BackgroundService.StartObservingRequest];
+        'BluetoothEmulation.simulatePreconnectedPeripheral': {
+            paramsType: [Protocol.BluetoothEmulation.SimulatePreconnectedPeripheralRequest];
             returnType: void;
         };
         /**
-         * Disables event updates for the service.
+         * Simulates an advertisement packet described in |entry| being received by
+         * the central.
          */
-        'BackgroundService.stopObserving': {
-            paramsType: [Protocol.BackgroundService.StopObservingRequest];
+        'BluetoothEmulation.simulateAdvertisement': {
+            paramsType: [Protocol.BluetoothEmulation.SimulateAdvertisementRequest];
             returnType: void;
         };
         /**
-         * Set the recording state for the service.
+         * 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.
          */
-        'BackgroundService.setRecording': {
-            paramsType: [Protocol.BackgroundService.SetRecordingRequest];
+        'BluetoothEmulation.simulateGATTOperationResponse': {
+            paramsType: [Protocol.BluetoothEmulation.SimulateGATTOperationResponseRequest];
             returnType: void;
         };
         /**
-         * Clears all stored data for the service.
+         * 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.
          */
-        'BackgroundService.clearEvents': {
-            paramsType: [Protocol.BackgroundService.ClearEventsRequest];
+        'BluetoothEmulation.simulateCharacteristicOperationResponse': {
+            paramsType: [Protocol.BluetoothEmulation.SimulateCharacteristicOperationResponseRequest];
+            returnType: void;
+        };
+        /**
+         * 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.
+         */
+        'BluetoothEmulation.simulateDescriptorOperationResponse': {
+            paramsType: [Protocol.BluetoothEmulation.SimulateDescriptorOperationResponseRequest];
+            returnType: void;
+        };
+        /**
+         * Adds a service with |serviceUuid| to the peripheral with |address|.
+         */
+        'BluetoothEmulation.addService': {
+            paramsType: [Protocol.BluetoothEmulation.AddServiceRequest];
+            returnType: Protocol.BluetoothEmulation.AddServiceResponse;
+        };
+        /**
+         * Removes the service respresented by |serviceId| from the simulated central.
+         */
+        'BluetoothEmulation.removeService': {
+            paramsType: [Protocol.BluetoothEmulation.RemoveServiceRequest];
+            returnType: void;
+        };
+        /**
+         * Adds a characteristic with |characteristicUuid| and |properties| to the
+         * service represented by |serviceId|.
+         */
+        'BluetoothEmulation.addCharacteristic': {
+            paramsType: [Protocol.BluetoothEmulation.AddCharacteristicRequest];
+            returnType: Protocol.BluetoothEmulation.AddCharacteristicResponse;
+        };
+        /**
+         * Removes the characteristic respresented by |characteristicId| from the
+         * simulated central.
+         */
+        'BluetoothEmulation.removeCharacteristic': {
+            paramsType: [Protocol.BluetoothEmulation.RemoveCharacteristicRequest];
+            returnType: void;
+        };
+        /**
+         * Adds a descriptor with |descriptorUuid| to the characteristic respresented
+         * by |characteristicId|.
+         */
+        'BluetoothEmulation.addDescriptor': {
+            paramsType: [Protocol.BluetoothEmulation.AddDescriptorRequest];
+            returnType: Protocol.BluetoothEmulation.AddDescriptorResponse;
+        };
+        /**
+         * Removes the descriptor with |descriptorId| from the simulated central.
+         */
+        'BluetoothEmulation.removeDescriptor': {
+            paramsType: [Protocol.BluetoothEmulation.RemoveDescriptorRequest];
+            returnType: void;
+        };
+        /**
+         * Simulates a GATT disconnection from the peripheral with |address|.
+         */
+        'BluetoothEmulation.simulateGATTDisconnection': {
+            paramsType: [Protocol.BluetoothEmulation.SimulateGATTDisconnectionRequest];
             returnType: void;
         };
         /**
          * Set permission settings for given origin.
+         * @experimental
          */
         'Browser.setPermission': {
             paramsType: [Protocol.Browser.SetPermissionRequest];
@@ -1733,6 +1928,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Grant specific permissions to the given origin and reject all others.
+         * @experimental
          */
         'Browser.grantPermissions': {
             paramsType: [Protocol.Browser.GrantPermissionsRequest];
@@ -1747,6 +1943,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Set the behavior when downloading a file.
+         * @experimental
          */
         'Browser.setDownloadBehavior': {
             paramsType: [Protocol.Browser.SetDownloadBehaviorRequest];
@@ -1754,6 +1951,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Cancel a download if in progress
+         * @experimental
          */
         'Browser.cancelDownload': {
             paramsType: [Protocol.Browser.CancelDownloadRequest];
@@ -1768,6 +1966,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Crashes browser on the main thread.
+         * @experimental
          */
         'Browser.crash': {
             paramsType: [];
@@ -1775,6 +1974,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Crashes GPU process.
+         * @experimental
          */
         'Browser.crashGpuProcess': {
             paramsType: [];
@@ -1790,6 +1990,7 @@ export namespace ProtocolMapping {
         /**
          * Returns the command line switches for the browser process if, and only if
          * --enable-automation is on the commandline.
+         * @experimental
          */
         'Browser.getBrowserCommandLine': {
             paramsType: [];
@@ -1797,6 +1998,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Get Chrome histograms.
+         * @experimental
          */
         'Browser.getHistograms': {
             paramsType: [Protocol.Browser.GetHistogramsRequest?];
@@ -1804,6 +2006,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Get a Chrome histogram by name.
+         * @experimental
          */
         'Browser.getHistogram': {
             paramsType: [Protocol.Browser.GetHistogramRequest];
@@ -1811,6 +2014,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Get position and size of the browser window.
+         * @experimental
          */
         'Browser.getWindowBounds': {
             paramsType: [Protocol.Browser.GetWindowBoundsRequest];
@@ -1818,6 +2022,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Get the browser window that contains the devtools target.
+         * @experimental
          */
         'Browser.getWindowForTarget': {
             paramsType: [Protocol.Browser.GetWindowForTargetRequest?];
@@ -1825,6 +2030,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Set position and/or size of the browser window.
+         * @experimental
          */
         'Browser.setWindowBounds': {
             paramsType: [Protocol.Browser.SetWindowBoundsRequest];
@@ -1832,6 +2038,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Set size of the browser contents resizing browser window as necessary.
+         * @experimental
          */
         'Browser.setContentsSize': {
             paramsType: [Protocol.Browser.SetContentsSizeRequest];
@@ -1839,6 +2046,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Set dock tile details, platform-specific.
+         * @experimental
          */
         'Browser.setDockTile': {
             paramsType: [Protocol.Browser.SetDockTileRequest?];
@@ -1846,6 +2054,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Invoke custom browser commands used by telemetry.
+         * @experimental
          */
         'Browser.executeBrowserCommand': {
             paramsType: [Protocol.Browser.ExecuteBrowserCommandRequest];
@@ -1942,11 +2151,15 @@ export namespace ProtocolMapping {
          * to the provided property syntax, the value is parsed using combined
          * syntax as if null `propertyName` was provided. If the value cannot be
          * resolved even then, return the provided value without any changes.
+         * @experimental
          */
         'CSS.resolveValues': {
             paramsType: [Protocol.CSS.ResolveValuesRequest];
             returnType: Protocol.CSS.ResolveValuesResponse;
         };
+        /**
+         * @experimental
+         */
         'CSS.getLonghandProperties': {
             paramsType: [Protocol.CSS.GetLonghandPropertiesRequest];
             returnType: Protocol.CSS.GetLonghandPropertiesResponse;
@@ -1962,6 +2175,7 @@ export namespace ProtocolMapping {
         /**
          * Returns the styles coming from animations & transitions
          * including the animation & transition styles coming from inheritance chain.
+         * @experimental
          */
         'CSS.getAnimatedStylesForNode': {
             paramsType: [Protocol.CSS.GetAnimatedStylesForNodeRequest];
@@ -1976,6 +2190,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Returns the values of the default UA-defined environment variables used in env()
+         * @experimental
          */
         'CSS.getEnvironmentVariables': {
             paramsType: [];
@@ -2008,6 +2223,7 @@ export namespace ProtocolMapping {
          * Given a DOM element identified by nodeId, getLayersForNode returns the root
          * layer for the nearest ancestor document or shadow root. The layer root contains
          * the full layer tree for the tree scope and their ordering.
+         * @experimental
          */
         'CSS.getLayersForNode': {
             paramsType: [Protocol.CSS.GetLayersForNodeRequest];
@@ -2016,6 +2232,7 @@ export namespace ProtocolMapping {
         /**
          * Given a CSS selector text and a style sheet ID, getLocationForSelector
          * returns an array of locations of the CSS selector in the style sheet.
+         * @experimental
          */
         'CSS.getLocationForSelector': {
             paramsType: [Protocol.CSS.GetLocationForSelectorRequest];
@@ -2028,6 +2245,7 @@ export namespace ProtocolMapping {
          * There can only be 1 node tracked for computed style updates
          * so passing a new node id removes tracking from the previous node.
          * Pass `undefined` to disable tracking.
+         * @experimental
          */
         'CSS.trackComputedStyleUpdatesForNode': {
             paramsType: [Protocol.CSS.TrackComputedStyleUpdatesForNodeRequest?];
@@ -2040,6 +2258,7 @@ export namespace ProtocolMapping {
          * The changes to computed style properties are only tracked for nodes pushed to the front-end
          * by the DOM agent. If no changes to the tracked properties occur after the node has been pushed
          * to the front-end, no updates will be issued for the node.
+         * @experimental
          */
         'CSS.trackComputedStyleUpdates': {
             paramsType: [Protocol.CSS.TrackComputedStyleUpdatesRequest];
@@ -2047,6 +2266,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Polls the next batch of computed style updates.
+         * @experimental
          */
         'CSS.takeComputedStyleUpdates': {
             paramsType: [];
@@ -2083,6 +2303,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Modifies the expression of a container query.
+         * @experimental
          */
         'CSS.setContainerQueryText': {
             paramsType: [Protocol.CSS.SetContainerQueryTextRequest];
@@ -2090,6 +2311,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Modifies the expression of a supports at-rule.
+         * @experimental
          */
         'CSS.setSupportsText': {
             paramsType: [Protocol.CSS.SetSupportsTextRequest];
@@ -2097,6 +2319,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Modifies the expression of a scope at-rule.
+         * @experimental
          */
         'CSS.setScopeText': {
             paramsType: [Protocol.CSS.SetScopeTextRequest];
@@ -2148,6 +2371,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Enables/disables rendering of local CSS fonts (enabled by default).
+         * @experimental
          */
         'CSS.setLocalFontsEnabled': {
             paramsType: [Protocol.CSS.SetLocalFontsEnabledRequest];
@@ -2237,6 +2461,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Collects class names for the node with given id and all of it's child nodes.
+         * @experimental
          */
         'DOM.collectClassNamesFromSubtree': {
             paramsType: [Protocol.DOM.CollectClassNamesFromSubtreeRequest];
@@ -2245,6 +2470,7 @@ export namespace ProtocolMapping {
         /**
          * Creates a deep copy of the specified node and places it into the target container before the
          * given anchor.
+         * @experimental
          */
         'DOM.copyTo': {
             paramsType: [Protocol.DOM.CopyToRequest];
@@ -2277,6 +2503,7 @@ export namespace ProtocolMapping {
         /**
          * Discards search results from the session with the given id. `getSearchResults` should no longer
          * be called for that search.
+         * @experimental
          */
         'DOM.discardSearchResults': {
             paramsType: [Protocol.DOM.DiscardSearchResultsRequest];
@@ -2313,6 +2540,7 @@ export namespace ProtocolMapping {
         /**
          * Returns quads that describe node position on the page. This method
          * might return multiple quads for inline nodes.
+         * @experimental
          */
         'DOM.getContentQuads': {
             paramsType: [Protocol.DOM.GetContentQuadsRequest?];
@@ -2330,6 +2558,7 @@ export namespace ProtocolMapping {
          * Returns the root DOM node (and optionally the subtree) to the caller.
          * Deprecated, as it is not designed to work well with the rest of the DOM agent.
          * Use DOMSnapshot.captureSnapshot instead.
+         * @deprecated
          */
         'DOM.getFlattenedDocument': {
             paramsType: [Protocol.DOM.GetFlattenedDocumentRequest?];
@@ -2337,6 +2566,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Finds nodes with a given computed style in a subtree.
+         * @experimental
          */
         'DOM.getNodesForSubtreeByStyle': {
             paramsType: [Protocol.DOM.GetNodesForSubtreeByStyleRequest];
@@ -2359,6 +2589,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Returns the id of the nearest ancestor that is a relayout boundary.
+         * @experimental
          */
         'DOM.getRelayoutBoundary': {
             paramsType: [Protocol.DOM.GetRelayoutBoundaryRequest];
@@ -2367,6 +2598,7 @@ export namespace ProtocolMapping {
         /**
          * Returns search results from given `fromIndex` to given `toIndex` from the search with the given
          * identifier.
+         * @experimental
          */
         'DOM.getSearchResults': {
             paramsType: [Protocol.DOM.GetSearchResultsRequest];
@@ -2395,6 +2627,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Marks last undoable state.
+         * @experimental
          */
         'DOM.markUndoableState': {
             paramsType: [];
@@ -2410,6 +2643,7 @@ export namespace ProtocolMapping {
         /**
          * Searches for a given string in the DOM tree. Use `getSearchResults` to access search results or
          * `cancelSearch` to end this search session.
+         * @experimental
          */
         'DOM.performSearch': {
             paramsType: [Protocol.DOM.PerformSearchRequest];
@@ -2417,6 +2651,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Requests that the node is sent to the caller given its path. // FIXME, use XPath
+         * @experimental
          */
         'DOM.pushNodeByPathToFrontend': {
             paramsType: [Protocol.DOM.PushNodeByPathToFrontendRequest];
@@ -2424,6 +2659,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Requests that a batch of nodes is sent to the caller given their backend node ids.
+         * @experimental
          */
         'DOM.pushNodesByBackendIdsToFrontend': {
             paramsType: [Protocol.DOM.PushNodesByBackendIdsToFrontendRequest];
@@ -2447,6 +2683,7 @@ export namespace ProtocolMapping {
          * Returns NodeIds of current top layer elements.
          * Top layer is rendered closest to the user within a viewport, therefore its elements always
          * appear on top of all other content.
+         * @experimental
          */
         'DOM.getTopLayerElements': {
             paramsType: [];
@@ -2454,6 +2691,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Returns the NodeId of the matched element according to certain relations.
+         * @experimental
          */
         'DOM.getElementByRelation': {
             paramsType: [Protocol.DOM.GetElementByRelationRequest];
@@ -2461,6 +2699,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Re-does the last undone action.
+         * @experimental
          */
         'DOM.redo': {
             paramsType: [];
@@ -2529,6 +2768,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Sets if stack traces should be captured for Nodes. See `Node.getNodeStackTraces`. Default is disabled.
+         * @experimental
          */
         'DOM.setNodeStackTracesEnabled': {
             paramsType: [Protocol.DOM.SetNodeStackTracesEnabledRequest];
@@ -2536,6 +2776,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Gets stack traces associated with a Node. As of now, only provides stack trace for Node creation.
+         * @experimental
          */
         'DOM.getNodeStackTraces': {
             paramsType: [Protocol.DOM.GetNodeStackTracesRequest];
@@ -2544,6 +2785,7 @@ export namespace ProtocolMapping {
         /**
          * Returns file information for the given
          * File wrapper.
+         * @experimental
          */
         'DOM.getFileInfo': {
             paramsType: [Protocol.DOM.GetFileInfoRequest];
@@ -2551,6 +2793,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Returns list of detached nodes
+         * @experimental
          */
         'DOM.getDetachedDomNodes': {
             paramsType: [];
@@ -2559,6 +2802,7 @@ export namespace ProtocolMapping {
         /**
          * Enables console to refer to the node with given id via $x (see Command Line API for more details
          * $x functions).
+         * @experimental
          */
         'DOM.setInspectedNode': {
             paramsType: [Protocol.DOM.SetInspectedNodeRequest];
@@ -2587,6 +2831,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Undoes the last performed action.
+         * @experimental
          */
         'DOM.undo': {
             paramsType: [];
@@ -2594,6 +2839,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Returns iframe node that owns iframe with the given domain.
+         * @experimental
          */
         'DOM.getFrameOwner': {
             paramsType: [Protocol.DOM.GetFrameOwnerRequest];
@@ -2605,6 +2851,7 @@ export namespace ProtocolMapping {
          * scroll-state or anchored elements. If no axes are provided and
          * queriesScrollState is false, the style container is returned, which is the
          * direct parent or the closest element with a matching container-name.
+         * @experimental
          */
         'DOM.getContainerForNode': {
             paramsType: [Protocol.DOM.GetContainerForNodeRequest];
@@ -2613,6 +2860,7 @@ export namespace ProtocolMapping {
         /**
          * Returns the descendants of a container query container that have
          * container queries against this container.
+         * @experimental
          */
         'DOM.getQueryingDescendantsForContainer': {
             paramsType: [Protocol.DOM.GetQueryingDescendantsForContainerRequest];
@@ -2621,6 +2869,7 @@ export namespace ProtocolMapping {
         /**
          * Returns the target anchor element of the given anchor query according to
          * https://www.w3.org/TR/css-anchor-position-1/#target.
+         * @experimental
          */
         'DOM.getAnchorElement': {
             paramsType: [Protocol.DOM.GetAnchorElementRequest];
@@ -2629,6 +2878,7 @@ export namespace ProtocolMapping {
         /**
          * When enabling, this API force-opens the popover identified by nodeId
          * and keeps it open until disabled.
+         * @experimental
          */
         'DOM.forceShowPopover': {
             paramsType: [Protocol.DOM.ForceShowPopoverRequest];
@@ -2657,6 +2907,8 @@ export namespace ProtocolMapping {
         };
         /**
          * Removes breakpoint on particular native event.
+         * @deprecated
+         * @experimental
          */
         'DOMDebugger.removeInstrumentationBreakpoint': {
             paramsType: [Protocol.DOMDebugger.RemoveInstrumentationBreakpointRequest];
@@ -2671,6 +2923,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Sets breakpoint on particular CSP violations.
+         * @experimental
          */
         'DOMDebugger.setBreakOnCSPViolation': {
             paramsType: [Protocol.DOMDebugger.SetBreakOnCSPViolationRequest];
@@ -2692,6 +2945,8 @@ export namespace ProtocolMapping {
         };
         /**
          * Sets breakpoint on particular native event.
+         * @deprecated
+         * @experimental
          */
         'DOMDebugger.setInstrumentationBreakpoint': {
             paramsType: [Protocol.DOMDebugger.SetInstrumentationBreakpointRequest];
@@ -2704,27 +2959,6 @@ export namespace ProtocolMapping {
             paramsType: [Protocol.DOMDebugger.SetXHRBreakpointRequest];
             returnType: void;
         };
-        /**
-         * Sets breakpoint on particular native event.
-         */
-        'EventBreakpoints.setInstrumentationBreakpoint': {
-            paramsType: [Protocol.EventBreakpoints.SetInstrumentationBreakpointRequest];
-            returnType: void;
-        };
-        /**
-         * Removes breakpoint on particular native event.
-         */
-        'EventBreakpoints.removeInstrumentationBreakpoint': {
-            paramsType: [Protocol.EventBreakpoints.RemoveInstrumentationBreakpointRequest];
-            returnType: void;
-        };
-        /**
-         * Removes all breakpoints
-         */
-        'EventBreakpoints.disable': {
-            paramsType: [];
-            returnType: void;
-        };
         /**
          * Disables DOM snapshot agent for the given page.
          */
@@ -2744,6 +2978,7 @@ export namespace ProtocolMapping {
          * template contents, and imported documents) in a flattened array, as well as layout and
          * white-listed computed style information for the nodes. Shadow DOM in the returned DOM tree is
          * flattened.
+         * @deprecated
          */
         'DOMSnapshot.getSnapshot': {
             paramsType: [Protocol.DOMSnapshot.GetSnapshotRequest];
@@ -2789,6 +3024,34 @@ export namespace ProtocolMapping {
             paramsType: [Protocol.DOMStorage.SetDOMStorageItemRequest];
             returnType: void;
         };
+        /**
+         * Enable events in this domain.
+         */
+        'DeviceAccess.enable': {
+            paramsType: [];
+            returnType: void;
+        };
+        /**
+         * Disable events in this domain.
+         */
+        'DeviceAccess.disable': {
+            paramsType: [];
+            returnType: void;
+        };
+        /**
+         * Select a device in response to a DeviceAccess.deviceRequestPrompted event.
+         */
+        'DeviceAccess.selectPrompt': {
+            paramsType: [Protocol.DeviceAccess.SelectPromptRequest];
+            returnType: void;
+        };
+        /**
+         * Cancel a prompt in response to a DeviceAccess.deviceRequestPrompted event.
+         */
+        'DeviceAccess.cancelPrompt': {
+            paramsType: [Protocol.DeviceAccess.CancelPromptRequest];
+            returnType: void;
+        };
         /**
          * Clears the overridden Device Orientation.
          */
@@ -2805,6 +3068,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Tells whether emulation is supported.
+         * @deprecated
          */
         'Emulation.canEmulate': {
             paramsType: [];
@@ -2826,6 +3090,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Requests that page scale factor is reset to initial values.
+         * @experimental
          */
         'Emulation.resetPageScaleFactor': {
             paramsType: [];
@@ -2833,6 +3098,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Enables or disables simulating a focused and active page.
+         * @experimental
          */
         'Emulation.setFocusEmulationEnabled': {
             paramsType: [Protocol.Emulation.SetFocusEmulationEnabledRequest];
@@ -2840,6 +3106,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Automatically render all web contents using a dark theme.
+         * @experimental
          */
         'Emulation.setAutoDarkModeOverride': {
             paramsType: [Protocol.Emulation.SetAutoDarkModeOverrideRequest?];
@@ -2863,6 +3130,7 @@ export namespace ProtocolMapping {
         /**
          * Overrides the values for env(safe-area-inset-*) and env(safe-area-max-inset-*). Unset values will cause the
          * respective variables to be undefined, even if previously overridden.
+         * @experimental
          */
         'Emulation.setSafeAreaInsetsOverride': {
             paramsType: [Protocol.Emulation.SetSafeAreaInsetsOverrideRequest];
@@ -2880,6 +3148,7 @@ export namespace ProtocolMapping {
         /**
          * Start reporting the given posture value to the Device Posture API.
          * This override can also be set in setDeviceMetricsOverride().
+         * @experimental
          */
         'Emulation.setDevicePostureOverride': {
             paramsType: [Protocol.Emulation.SetDevicePostureOverrideRequest];
@@ -2890,6 +3159,7 @@ export namespace ProtocolMapping {
          * or setDevicePostureOverride() and starts using posture information from the
          * platform again.
          * Does nothing if no override is set.
+         * @experimental
          */
         'Emulation.clearDevicePostureOverride': {
             paramsType: [];
@@ -2898,6 +3168,7 @@ export namespace ProtocolMapping {
         /**
          * Start using the given display features to pupulate the Viewport Segments API.
          * This override can also be set in setDeviceMetricsOverride().
+         * @experimental
          */
         'Emulation.setDisplayFeaturesOverride': {
             paramsType: [Protocol.Emulation.SetDisplayFeaturesOverrideRequest];
@@ -2908,19 +3179,29 @@ export namespace ProtocolMapping {
          * or setDisplayFeaturesOverride() and starts using display features from the
          * platform again.
          * Does nothing if no override is set.
+         * @experimental
          */
         'Emulation.clearDisplayFeaturesOverride': {
             paramsType: [];
             returnType: void;
         };
+        /**
+         * @experimental
+         */
         'Emulation.setScrollbarsHidden': {
             paramsType: [Protocol.Emulation.SetScrollbarsHiddenRequest];
             returnType: void;
         };
+        /**
+         * @experimental
+         */
         'Emulation.setDocumentCookieDisabled': {
             paramsType: [Protocol.Emulation.SetDocumentCookieDisabledRequest];
             returnType: void;
         };
+        /**
+         * @experimental
+         */
         'Emulation.setEmitTouchEventsForMouse': {
             paramsType: [Protocol.Emulation.SetEmitTouchEventsForMouseRequest];
             returnType: void;
@@ -2954,6 +3235,9 @@ export namespace ProtocolMapping {
             paramsType: [Protocol.Emulation.SetGeolocationOverrideRequest?];
             returnType: void;
         };
+        /**
+         * @experimental
+         */
         'Emulation.getOverriddenSensorInformation': {
             paramsType: [Protocol.Emulation.GetOverriddenSensorInformationRequest];
             returnType: Protocol.Emulation.GetOverriddenSensorInformationResponse;
@@ -2964,6 +3248,7 @@ export namespace ProtocolMapping {
          * data from a real hardware sensor. Otherwise, existing virtual
          * sensor-backend Sensor objects will fire an error event and new calls to
          * Sensor.start() will attempt to use a real sensor instead.
+         * @experimental
          */
         'Emulation.setSensorOverrideEnabled': {
             paramsType: [Protocol.Emulation.SetSensorOverrideEnabledRequest];
@@ -2972,6 +3257,7 @@ export namespace ProtocolMapping {
         /**
          * Updates the sensor readings reported by a sensor type previously overridden
          * by setSensorOverrideEnabled.
+         * @experimental
          */
         'Emulation.setSensorOverrideReadings': {
             paramsType: [Protocol.Emulation.SetSensorOverrideReadingsRequest];
@@ -2982,6 +3268,7 @@ export namespace ProtocolMapping {
          * Pressure API, so that updates to PressureObserver.observe() are provided
          * via setPressureStateOverride instead of being retrieved from
          * platform-provided telemetry data.
+         * @experimental
          */
         'Emulation.setPressureSourceOverrideEnabled': {
             paramsType: [Protocol.Emulation.SetPressureSourceOverrideEnabledRequest];
@@ -2992,6 +3279,7 @@ export namespace ProtocolMapping {
          * Provides a given pressure state that will be processed and eventually be
          * delivered to PressureObserver users. |source| must have been previously
          * overridden by setPressureSourceOverrideEnabled.
+         * @experimental
          */
         'Emulation.setPressureStateOverride': {
             paramsType: [Protocol.Emulation.SetPressureStateOverrideRequest];
@@ -3001,6 +3289,7 @@ export namespace ProtocolMapping {
          * Provides a given pressure data set that will be processed and eventually be
          * delivered to PressureObserver users. |source| must have been previously
          * overridden by setPressureSourceOverrideEnabled.
+         * @experimental
          */
         'Emulation.setPressureDataOverride': {
             paramsType: [Protocol.Emulation.SetPressureDataOverrideRequest];
@@ -3022,6 +3311,8 @@ export namespace ProtocolMapping {
         };
         /**
          * Overrides value returned by the javascript navigator object.
+         * @deprecated
+         * @experimental
          */
         'Emulation.setNavigatorOverrides': {
             paramsType: [Protocol.Emulation.SetNavigatorOverridesRequest];
@@ -3029,6 +3320,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Sets a specified page scale factor.
+         * @experimental
          */
         'Emulation.setPageScaleFactor': {
             paramsType: [Protocol.Emulation.SetPageScaleFactorRequest];
@@ -3051,6 +3343,7 @@ export namespace ProtocolMapping {
         /**
          * Turns on virtual time for all frames (replacing real-time with a synthetic time source) and sets
          * the current virtual time policy.  Note this supersedes any previous time budget.
+         * @experimental
          */
         'Emulation.setVirtualTimePolicy': {
             paramsType: [Protocol.Emulation.SetVirtualTimePolicyRequest];
@@ -3058,6 +3351,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Overrides default host system locale with the specified one.
+         * @experimental
          */
         'Emulation.setLocaleOverride': {
             paramsType: [Protocol.Emulation.SetLocaleOverrideRequest?];
@@ -3074,22 +3368,31 @@ export namespace ProtocolMapping {
          * Resizes the frame/viewport of the page. Note that this does not affect the frame's container
          * (e.g. browser window). Can be used to produce screenshots of the specified size. Not supported
          * on Android.
+         * @deprecated
+         * @experimental
          */
         'Emulation.setVisibleSize': {
             paramsType: [Protocol.Emulation.SetVisibleSizeRequest];
             returnType: void;
         };
+        /**
+         * @experimental
+         */
         'Emulation.setDisabledImageTypes': {
             paramsType: [Protocol.Emulation.SetDisabledImageTypesRequest];
             returnType: void;
         };
         /**
          * Override the value of navigator.connection.saveData
+         * @experimental
          */
         'Emulation.setDataSaverOverride': {
             paramsType: [Protocol.Emulation.SetDataSaverOverrideRequest?];
             returnType: void;
         };
+        /**
+         * @experimental
+         */
         'Emulation.setHardwareConcurrencyOverride': {
             paramsType: [Protocol.Emulation.SetHardwareConcurrencyOverrideRequest];
             returnType: void;
@@ -3104,6 +3407,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Allows overriding the automation flag.
+         * @experimental
          */
         'Emulation.setAutomationOverride': {
             paramsType: [Protocol.Emulation.SetAutomationOverrideRequest];
@@ -3112,78 +3416,293 @@ export namespace ProtocolMapping {
         /**
          * Allows overriding the difference between the small and large viewport sizes, which determine the
          * value of the `svh` and `lvh` unit, respectively. Only supported for top-level frames.
+         * @experimental
          */
         'Emulation.setSmallViewportHeightDifferenceOverride': {
             paramsType: [Protocol.Emulation.SetSmallViewportHeightDifferenceOverrideRequest];
             returnType: void;
         };
         /**
-         * 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
-         * BeginFrameControl. Designed for use with --run-all-compositor-stages-before-draw, see also
-         * https://goo.gle/chrome-headless-rendering for more background.
+         * Returns device's screen configuration.
+         * @experimental
          */
-        'HeadlessExperimental.beginFrame': {
-            paramsType: [Protocol.HeadlessExperimental.BeginFrameRequest?];
-            returnType: Protocol.HeadlessExperimental.BeginFrameResponse;
+        'Emulation.getScreenInfos': {
+            paramsType: [];
+            returnType: Protocol.Emulation.GetScreenInfosResponse;
         };
         /**
-         * Disables headless events for the target.
+         * Add a new screen to the device. Only supported in headless mode.
+         * @experimental
          */
-        'HeadlessExperimental.disable': {
-            paramsType: [];
-            returnType: void;
+        'Emulation.addScreen': {
+            paramsType: [Protocol.Emulation.AddScreenRequest];
+            returnType: Protocol.Emulation.AddScreenResponse;
         };
         /**
-         * Enables headless events for the target.
+         * Remove screen from the device. Only supported in headless mode.
+         * @experimental
          */
-        'HeadlessExperimental.enable': {
-            paramsType: [];
+        'Emulation.removeScreen': {
+            paramsType: [Protocol.Emulation.RemoveScreenRequest];
             returnType: void;
         };
         /**
-         * Close the stream, discard any temporary backing storage.
+         * Sets breakpoint on particular native event.
          */
-        'IO.close': {
-            paramsType: [Protocol.IO.CloseRequest];
+        'EventBreakpoints.setInstrumentationBreakpoint': {
+            paramsType: [Protocol.EventBreakpoints.SetInstrumentationBreakpointRequest];
             returnType: void;
         };
         /**
-         * Read a chunk of the stream
+         * Removes breakpoint on particular native event.
          */
-        'IO.read': {
-            paramsType: [Protocol.IO.ReadRequest];
-            returnType: Protocol.IO.ReadResponse;
+        'EventBreakpoints.removeInstrumentationBreakpoint': {
+            paramsType: [Protocol.EventBreakpoints.RemoveInstrumentationBreakpointRequest];
+            returnType: void;
         };
         /**
-         * Return UUID of Blob object specified by a remote object id.
+         * Removes all breakpoints
          */
-        'IO.resolveBlob': {
-            paramsType: [Protocol.IO.ResolveBlobRequest];
-            returnType: Protocol.IO.ResolveBlobResponse;
-        };
-        'FileSystem.getDirectory': {
-            paramsType: [Protocol.FileSystem.GetDirectoryRequest];
-            returnType: Protocol.FileSystem.GetDirectoryResponse;
+        'EventBreakpoints.disable': {
+            paramsType: [];
+            returnType: void;
         };
         /**
-         * Clears all entries from an object store.
+         * 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.
          */
-        'IndexedDB.clearObjectStore': {
-            paramsType: [Protocol.IndexedDB.ClearObjectStoreRequest];
-            returnType: void;
+        'Extensions.loadUnpacked': {
+            paramsType: [Protocol.Extensions.LoadUnpackedRequest];
+            returnType: Protocol.Extensions.LoadUnpackedResponse;
         };
         /**
-         * Deletes a database.
+         * 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.
          */
-        'IndexedDB.deleteDatabase': {
-            paramsType: [Protocol.IndexedDB.DeleteDatabaseRequest];
+        'Extensions.uninstall': {
+            paramsType: [Protocol.Extensions.UninstallRequest];
             returnType: void;
         };
         /**
-         * Delete a range of entries from an object store
+         * Gets data from extension storage in the given `storageArea`. If `keys` is
+         * specified, these are used to filter the result.
          */
-        'IndexedDB.deleteObjectStoreEntries': {
+        'Extensions.getStorageItems': {
+            paramsType: [Protocol.Extensions.GetStorageItemsRequest];
+            returnType: Protocol.Extensions.GetStorageItemsResponse;
+        };
+        /**
+         * Removes `keys` from extension storage in the given `storageArea`.
+         */
+        'Extensions.removeStorageItems': {
+            paramsType: [Protocol.Extensions.RemoveStorageItemsRequest];
+            returnType: void;
+        };
+        /**
+         * Clears extension storage in the given `storageArea`.
+         */
+        'Extensions.clearStorageItems': {
+            paramsType: [Protocol.Extensions.ClearStorageItemsRequest];
+            returnType: void;
+        };
+        /**
+         * Sets `values` in extension storage in the given `storageArea`. The provided `values`
+         * will be merged with existing values in the storage area.
+         */
+        'Extensions.setStorageItems': {
+            paramsType: [Protocol.Extensions.SetStorageItemsRequest];
+            returnType: void;
+        };
+        'FedCm.enable': {
+            paramsType: [Protocol.FedCm.EnableRequest?];
+            returnType: void;
+        };
+        'FedCm.disable': {
+            paramsType: [];
+            returnType: void;
+        };
+        'FedCm.selectAccount': {
+            paramsType: [Protocol.FedCm.SelectAccountRequest];
+            returnType: void;
+        };
+        'FedCm.clickDialogButton': {
+            paramsType: [Protocol.FedCm.ClickDialogButtonRequest];
+            returnType: void;
+        };
+        'FedCm.openUrl': {
+            paramsType: [Protocol.FedCm.OpenUrlRequest];
+            returnType: void;
+        };
+        'FedCm.dismissDialog': {
+            paramsType: [Protocol.FedCm.DismissDialogRequest];
+            returnType: void;
+        };
+        /**
+         * 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.
+         */
+        'FedCm.resetCooldown': {
+            paramsType: [];
+            returnType: void;
+        };
+        /**
+         * Disables the fetch domain.
+         */
+        'Fetch.disable': {
+            paramsType: [];
+            returnType: void;
+        };
+        /**
+         * Enables issuing of requestPaused events. A request will be paused until client
+         * calls one of failRequest, fulfillRequest or continueRequest/continueWithAuth.
+         */
+        'Fetch.enable': {
+            paramsType: [Protocol.Fetch.EnableRequest?];
+            returnType: void;
+        };
+        /**
+         * Causes the request to fail with specified reason.
+         */
+        'Fetch.failRequest': {
+            paramsType: [Protocol.Fetch.FailRequestRequest];
+            returnType: void;
+        };
+        /**
+         * Provides response to the request.
+         */
+        'Fetch.fulfillRequest': {
+            paramsType: [Protocol.Fetch.FulfillRequestRequest];
+            returnType: void;
+        };
+        /**
+         * Continues the request, optionally modifying some of its parameters.
+         */
+        'Fetch.continueRequest': {
+            paramsType: [Protocol.Fetch.ContinueRequestRequest];
+            returnType: void;
+        };
+        /**
+         * Continues a request supplying authChallengeResponse following authRequired event.
+         */
+        'Fetch.continueWithAuth': {
+            paramsType: [Protocol.Fetch.ContinueWithAuthRequest];
+            returnType: void;
+        };
+        /**
+         * 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
+         */
+        'Fetch.continueResponse': {
+            paramsType: [Protocol.Fetch.ContinueResponseRequest];
+            returnType: void;
+        };
+        /**
+         * 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.
+         */
+        'Fetch.getResponseBody': {
+            paramsType: [Protocol.Fetch.GetResponseBodyRequest];
+            returnType: Protocol.Fetch.GetResponseBodyResponse;
+        };
+        /**
+         * 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.
+         */
+        'Fetch.takeResponseBodyAsStream': {
+            paramsType: [Protocol.Fetch.TakeResponseBodyAsStreamRequest];
+            returnType: Protocol.Fetch.TakeResponseBodyAsStreamResponse;
+        };
+        'FileSystem.getDirectory': {
+            paramsType: [Protocol.FileSystem.GetDirectoryRequest];
+            returnType: Protocol.FileSystem.GetDirectoryResponse;
+        };
+        /**
+         * 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
+         * BeginFrameControl. Designed for use with --run-all-compositor-stages-before-draw, see also
+         * https://goo.gle/chrome-headless-rendering for more background.
+         */
+        'HeadlessExperimental.beginFrame': {
+            paramsType: [Protocol.HeadlessExperimental.BeginFrameRequest?];
+            returnType: Protocol.HeadlessExperimental.BeginFrameResponse;
+        };
+        /**
+         * Disables headless events for the target.
+         * @deprecated
+         */
+        'HeadlessExperimental.disable': {
+            paramsType: [];
+            returnType: void;
+        };
+        /**
+         * Enables headless events for the target.
+         * @deprecated
+         */
+        'HeadlessExperimental.enable': {
+            paramsType: [];
+            returnType: void;
+        };
+        /**
+         * Close the stream, discard any temporary backing storage.
+         */
+        'IO.close': {
+            paramsType: [Protocol.IO.CloseRequest];
+            returnType: void;
+        };
+        /**
+         * Read a chunk of the stream
+         */
+        'IO.read': {
+            paramsType: [Protocol.IO.ReadRequest];
+            returnType: Protocol.IO.ReadResponse;
+        };
+        /**
+         * Return UUID of Blob object specified by a remote object id.
+         */
+        'IO.resolveBlob': {
+            paramsType: [Protocol.IO.ResolveBlobRequest];
+            returnType: Protocol.IO.ResolveBlobResponse;
+        };
+        /**
+         * Clears all entries from an object store.
+         */
+        'IndexedDB.clearObjectStore': {
+            paramsType: [Protocol.IndexedDB.ClearObjectStoreRequest];
+            returnType: void;
+        };
+        /**
+         * Deletes a database.
+         */
+        'IndexedDB.deleteDatabase': {
+            paramsType: [Protocol.IndexedDB.DeleteDatabaseRequest];
+            returnType: void;
+        };
+        /**
+         * Delete a range of entries from an object store
+         */
+        'IndexedDB.deleteObjectStoreEntries': {
             paramsType: [Protocol.IndexedDB.DeleteObjectStoreEntriesRequest];
             returnType: void;
         };
@@ -3231,6 +3750,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Dispatches a drag event into the page.
+         * @experimental
          */
         'Input.dispatchDragEvent': {
             paramsType: [Protocol.Input.DispatchDragEventRequest];
@@ -3246,6 +3766,7 @@ export namespace ProtocolMapping {
         /**
          * This method emulates inserting text that doesn't come from a key press,
          * for example an emoji keyboard or an IME.
+         * @experimental
          */
         'Input.insertText': {
             paramsType: [Protocol.Input.InsertTextRequest];
@@ -3255,6 +3776,7 @@ export namespace ProtocolMapping {
          * This method sets the current candidate text for IME.
          * Use imeCommitComposition to commit the final text.
          * Use imeSetComposition with empty string as text to cancel composition.
+         * @experimental
          */
         'Input.imeSetComposition': {
             paramsType: [Protocol.Input.ImeSetCompositionRequest];
@@ -3283,6 +3805,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Emulates touch event from the mouse event parameters.
+         * @experimental
          */
         'Input.emulateTouchFromMouseEvent': {
             paramsType: [Protocol.Input.EmulateTouchFromMouseEventRequest];
@@ -3298,6 +3821,7 @@ export namespace ProtocolMapping {
         /**
          * Prevents default drag and drop behavior and instead emits `Input.dragIntercepted` events.
          * Drag and drop behavior can be directly controlled via `Input.dispatchDragEvent`.
+         * @experimental
          */
         'Input.setInterceptDrags': {
             paramsType: [Protocol.Input.SetInterceptDragsRequest];
@@ -3305,6 +3829,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Synthesizes a pinch gesture over a time period by issuing appropriate touch events.
+         * @experimental
          */
         'Input.synthesizePinchGesture': {
             paramsType: [Protocol.Input.SynthesizePinchGestureRequest];
@@ -3312,6 +3837,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Synthesizes a scroll gesture over a time period by issuing appropriate touch events.
+         * @experimental
          */
         'Input.synthesizeScrollGesture': {
             paramsType: [Protocol.Input.SynthesizeScrollGestureRequest];
@@ -3319,6 +3845,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Synthesizes a tap gesture over a time period by issuing appropriate touch events.
+         * @experimental
          */
         'Input.synthesizeTapGesture': {
             paramsType: [Protocol.Input.SynthesizeTapGestureRequest];
@@ -3434,6 +3961,20 @@ export namespace ProtocolMapping {
             paramsType: [];
             returnType: void;
         };
+        /**
+         * Enables the Media domain
+         */
+        'Media.enable': {
+            paramsType: [];
+            returnType: void;
+        };
+        /**
+         * Disables the Media domain.
+         */
+        'Media.disable': {
+            paramsType: [];
+            returnType: void;
+        };
         /**
          * Retruns current DOM object counters.
          */
@@ -3517,6 +4058,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Sets a list of content encodings that will be accepted. Empty list means no encoding is accepted.
+         * @experimental
          */
         'Network.setAcceptedEncodings': {
             paramsType: [Protocol.Network.SetAcceptedEncodingsRequest];
@@ -3524,6 +4066,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Clears accepted encodings set by setAcceptedEncodings
+         * @experimental
          */
         'Network.clearAcceptedEncodingsOverride': {
             paramsType: [];
@@ -3531,6 +4074,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Tells whether clearing browser cache is supported.
+         * @deprecated
          */
         'Network.canClearBrowserCache': {
             paramsType: [];
@@ -3538,6 +4082,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Tells whether clearing browser cookies is supported.
+         * @deprecated
          */
         'Network.canClearBrowserCookies': {
             paramsType: [];
@@ -3545,6 +4090,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Tells whether emulation of network conditions is supported.
+         * @deprecated
          */
         'Network.canEmulateNetworkConditions': {
             paramsType: [];
@@ -3570,6 +4116,8 @@ export namespace ProtocolMapping {
          * fetch occurs as a result which encounters a redirect an additional Network.requestIntercepted
          * event will be sent with the same InterceptionId.
          * Deprecated, use Fetch.continueRequest, Fetch.fulfillRequest and Fetch.failRequest instead.
+         * @deprecated
+         * @experimental
          */
         'Network.continueInterceptedRequest': {
             paramsType: [Protocol.Network.ContinueInterceptedRequestRequest];
@@ -3607,6 +4155,7 @@ export namespace ProtocolMapping {
          * Returns all browser cookies. Depending on the backend support, will return detailed cookie
          * information in the `cookies` field.
          * Deprecated. Use Storage.getCookies instead.
+         * @deprecated
          */
         'Network.getAllCookies': {
             paramsType: [];
@@ -3614,6 +4163,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Returns the DER-encoded certificate.
+         * @experimental
          */
         'Network.getCertificate': {
             paramsType: [Protocol.Network.GetCertificateRequest];
@@ -3643,6 +4193,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Returns content served for the given currently intercepted request.
+         * @experimental
          */
         'Network.getResponseBodyForInterception': {
             paramsType: [Protocol.Network.GetResponseBodyForInterceptionRequest];
@@ -3653,6 +4204,7 @@ export namespace ProtocolMapping {
          * the intercepted request can't be continued as is -- you either need to cancel it or to provide
          * the response body. The stream only supports sequential read, IO.read will fail if the position
          * is specified.
+         * @experimental
          */
         'Network.takeResponseBodyForInterceptionAsStream': {
             paramsType: [Protocol.Network.TakeResponseBodyForInterceptionAsStreamRequest];
@@ -3662,6 +4214,7 @@ export namespace ProtocolMapping {
          * This method sends a new XMLHttpRequest which is identical to the original one. The following
          * parameters should be identical: method, url, async, request body, extra headers, withCredentials
          * attribute, user, password.
+         * @experimental
          */
         'Network.replayXHR': {
             paramsType: [Protocol.Network.ReplayXHRRequest];
@@ -3669,6 +4222,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Searches for given string in response content.
+         * @experimental
          */
         'Network.searchInResponseBody': {
             paramsType: [Protocol.Network.SearchInResponseBodyRequest];
@@ -3676,6 +4230,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Blocks URLs from loading.
+         * @experimental
          */
         'Network.setBlockedURLs': {
             paramsType: [Protocol.Network.SetBlockedURLsRequest];
@@ -3718,6 +4273,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Specifies whether to attach a page script stack id in requests
+         * @experimental
          */
         'Network.setAttachDebugStack': {
             paramsType: [Protocol.Network.SetAttachDebugStackRequest];
@@ -3726,6 +4282,8 @@ export namespace ProtocolMapping {
         /**
          * Sets the requests to intercept that match the provided patterns and optionally resource types.
          * Deprecated, please use Fetch.enable instead.
+         * @deprecated
+         * @experimental
          */
         'Network.setRequestInterception': {
             paramsType: [Protocol.Network.SetRequestInterceptionRequest];
@@ -3741,6 +4299,7 @@ export namespace ProtocolMapping {
         /**
          * Enables streaming of the response for the given requestId.
          * If enabled, the dataReceived event contains the data that was received during streaming.
+         * @experimental
          */
         'Network.streamResourceContent': {
             paramsType: [Protocol.Network.StreamResourceContentRequest];
@@ -3748,6 +4307,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Returns information about the COEP/COOP isolation status.
+         * @experimental
          */
         'Network.getSecurityIsolationStatus': {
             paramsType: [Protocol.Network.GetSecurityIsolationStatusRequest?];
@@ -3756,6 +4316,7 @@ export namespace ProtocolMapping {
         /**
          * Enables tracking for the Reporting API, events generated by the Reporting API will now be delivered to the client.
          * Enabling triggers 'reportingApiReportAdded' for all existing reports.
+         * @experimental
          */
         'Network.enableReportingApi': {
             paramsType: [Protocol.Network.EnableReportingApiRequest];
@@ -3763,6 +4324,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Fetches the resource and returns the content.
+         * @experimental
          */
         'Network.loadNetworkResource': {
             paramsType: [Protocol.Network.LoadNetworkResourceRequest];
@@ -3771,6 +4333,7 @@ export namespace ProtocolMapping {
         /**
          * Sets Controls for third-party cookie access
          * Page reload is required before the new cookie behavior will be observed
+         * @experimental
          */
         'Network.setCookieControls': {
             paramsType: [Protocol.Network.SetCookieControlsRequest];
@@ -3823,6 +4386,7 @@ export namespace ProtocolMapping {
          * Deprecated: Doesn't work reliably and cannot be fixed due to process
          * separation (the owner node might be in a different process). Determine
          * the owner node in the client and use highlightNode.
+         * @deprecated
          */
         'Overlay.highlightFrame': {
             paramsType: [Protocol.Overlay.HighlightFrameRequest];
@@ -3845,6 +4409,9 @@ export namespace ProtocolMapping {
         };
         /**
          * 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).
          */
         'Overlay.highlightRect': {
             paramsType: [Protocol.Overlay.HighlightRectRequest];
@@ -3933,6 +4500,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Deprecated, no longer has any effect.
+         * @deprecated
          */
         'Overlay.setShowHitTestBorders': {
             paramsType: [Protocol.Overlay.SetShowHitTestBordersRequest];
@@ -3940,6 +4508,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Deprecated, no longer has any effect.
+         * @deprecated
          */
         'Overlay.setShowWebVitals': {
             paramsType: [Protocol.Overlay.SetShowWebVitalsRequest];
@@ -3974,43 +4543,145 @@ export namespace ProtocolMapping {
             returnType: void;
         };
         /**
-         * Deprecated, please use addScriptToEvaluateOnNewDocument instead.
-         */
-        'Page.addScriptToEvaluateOnLoad': {
-            paramsType: [Protocol.Page.AddScriptToEvaluateOnLoadRequest];
-            returnType: Protocol.Page.AddScriptToEvaluateOnLoadResponse;
-        };
-        /**
-         * Evaluates given script in every frame upon creation (before loading frame's scripts).
-         */
-        'Page.addScriptToEvaluateOnNewDocument': {
-            paramsType: [Protocol.Page.AddScriptToEvaluateOnNewDocumentRequest];
-            returnType: Protocol.Page.AddScriptToEvaluateOnNewDocumentResponse;
-        };
-        /**
-         * Brings page to front (activates tab).
-         */
-        'Page.bringToFront': {
-            paramsType: [];
-            returnType: void;
-        };
-        /**
-         * Capture page screenshot.
+         * Returns the following OS state for the given manifest id.
          */
-        'Page.captureScreenshot': {
-            paramsType: [Protocol.Page.CaptureScreenshotRequest?];
-            returnType: Protocol.Page.CaptureScreenshotResponse;
+        'PWA.getOsAppState': {
+            paramsType: [Protocol.PWA.GetOsAppStateRequest];
+            returnType: Protocol.PWA.GetOsAppStateResponse;
         };
         /**
-         * Returns a snapshot of the page as a string. For MHTML format, the serialization includes
-         * iframes, shadow DOM, external resources, and element-inline styles.
-         */
-        'Page.captureSnapshot': {
+         * 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.
+         */
+        'PWA.install': {
+            paramsType: [Protocol.PWA.InstallRequest];
+            returnType: void;
+        };
+        /**
+         * Uninstalls the given manifest_id and closes any opened app windows.
+         */
+        'PWA.uninstall': {
+            paramsType: [Protocol.PWA.UninstallRequest];
+            returnType: void;
+        };
+        /**
+         * 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.
+         */
+        'PWA.launch': {
+            paramsType: [Protocol.PWA.LaunchRequest];
+            returnType: Protocol.PWA.LaunchResponse;
+        };
+        /**
+         * 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.
+         */
+        'PWA.launchFilesInApp': {
+            paramsType: [Protocol.PWA.LaunchFilesInAppRequest];
+            returnType: Protocol.PWA.LaunchFilesInAppResponse;
+        };
+        /**
+         * 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.
+         */
+        'PWA.openCurrentPageInApp': {
+            paramsType: [Protocol.PWA.OpenCurrentPageInAppRequest];
+            returnType: void;
+        };
+        /**
+         * 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.
+         */
+        'PWA.changeAppUserSettings': {
+            paramsType: [Protocol.PWA.ChangeAppUserSettingsRequest];
+            returnType: void;
+        };
+        /**
+         * Deprecated, please use addScriptToEvaluateOnNewDocument instead.
+         * @deprecated
+         * @experimental
+         */
+        'Page.addScriptToEvaluateOnLoad': {
+            paramsType: [Protocol.Page.AddScriptToEvaluateOnLoadRequest];
+            returnType: Protocol.Page.AddScriptToEvaluateOnLoadResponse;
+        };
+        /**
+         * Evaluates given script in every frame upon creation (before loading frame's scripts).
+         */
+        'Page.addScriptToEvaluateOnNewDocument': {
+            paramsType: [Protocol.Page.AddScriptToEvaluateOnNewDocumentRequest];
+            returnType: Protocol.Page.AddScriptToEvaluateOnNewDocumentResponse;
+        };
+        /**
+         * Brings page to front (activates tab).
+         */
+        'Page.bringToFront': {
+            paramsType: [];
+            returnType: void;
+        };
+        /**
+         * Capture page screenshot.
+         */
+        'Page.captureScreenshot': {
+            paramsType: [Protocol.Page.CaptureScreenshotRequest?];
+            returnType: Protocol.Page.CaptureScreenshotResponse;
+        };
+        /**
+         * Returns a snapshot of the page as a string. For MHTML format, the serialization includes
+         * iframes, shadow DOM, external resources, and element-inline styles.
+         * @experimental
+         */
+        'Page.captureSnapshot': {
             paramsType: [Protocol.Page.CaptureSnapshotRequest?];
             returnType: Protocol.Page.CaptureSnapshotResponse;
         };
         /**
          * Clears the overridden device metrics.
+         * @deprecated
+         * @experimental
          */
         'Page.clearDeviceMetricsOverride': {
             paramsType: [];
@@ -4018,6 +4689,8 @@ export namespace ProtocolMapping {
         };
         /**
          * Clears the overridden Device Orientation.
+         * @deprecated
+         * @experimental
          */
         'Page.clearDeviceOrientationOverride': {
             paramsType: [];
@@ -4025,6 +4698,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Clears the overridden Geolocation Position and Error.
+         * @deprecated
          */
         'Page.clearGeolocationOverride': {
             paramsType: [];
@@ -4039,6 +4713,8 @@ export namespace ProtocolMapping {
         };
         /**
          * Deletes browser cookie with given name, domain and path.
+         * @deprecated
+         * @experimental
          */
         'Page.deleteCookie': {
             paramsType: [Protocol.Page.DeleteCookieRequest];
@@ -4069,12 +4745,17 @@ export namespace ProtocolMapping {
             paramsType: [Protocol.Page.GetAppManifestRequest?];
             returnType: Protocol.Page.GetAppManifestResponse;
         };
+        /**
+         * @experimental
+         */
         'Page.getInstallabilityErrors': {
             paramsType: [];
             returnType: Protocol.Page.GetInstallabilityErrorsResponse;
         };
         /**
          * Deprecated because it's not guaranteed that the returned icon is in fact the one used for PWA installation.
+         * @deprecated
+         * @experimental
          */
         'Page.getManifestIcons': {
             paramsType: [];
@@ -4083,11 +4764,15 @@ export namespace ProtocolMapping {
         /**
          * Returns the unique (PWA) app id.
          * Only returns values if the feature flag 'WebAppEnableManifestId' is enabled
+         * @experimental
          */
         'Page.getAppId': {
             paramsType: [];
             returnType: Protocol.Page.GetAppIdResponse;
         };
+        /**
+         * @experimental
+         */
         'Page.getAdScriptAncestry': {
             paramsType: [Protocol.Page.GetAdScriptAncestryRequest];
             returnType: Protocol.Page.GetAdScriptAncestryResponse;
@@ -4122,6 +4807,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Returns content of the given resource.
+         * @experimental
          */
         'Page.getResourceContent': {
             paramsType: [Protocol.Page.GetResourceContentRequest];
@@ -4129,6 +4815,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Returns present frame / resource tree structure.
+         * @experimental
          */
         'Page.getResourceTree': {
             paramsType: [];
@@ -4171,6 +4858,8 @@ export namespace ProtocolMapping {
         };
         /**
          * Deprecated, please use removeScriptToEvaluateOnNewDocument instead.
+         * @deprecated
+         * @experimental
          */
         'Page.removeScriptToEvaluateOnLoad': {
             paramsType: [Protocol.Page.RemoveScriptToEvaluateOnLoadRequest];
@@ -4185,6 +4874,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Acknowledges that a screencast frame has been received by the frontend.
+         * @experimental
          */
         'Page.screencastFrameAck': {
             paramsType: [Protocol.Page.ScreencastFrameAckRequest];
@@ -4192,6 +4882,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Searches for given string in resource content.
+         * @experimental
          */
         'Page.searchInResource': {
             paramsType: [Protocol.Page.SearchInResourceRequest];
@@ -4199,6 +4890,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Enable Chrome's experimental ad filter on all sites.
+         * @experimental
          */
         'Page.setAdBlockingEnabled': {
             paramsType: [Protocol.Page.SetAdBlockingEnabledRequest];
@@ -4213,6 +4905,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Get Permissions Policy state on given frame.
+         * @experimental
          */
         'Page.getPermissionsPolicyState': {
             paramsType: [Protocol.Page.GetPermissionsPolicyStateRequest];
@@ -4220,6 +4913,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Get Origin Trials on given frame.
+         * @experimental
          */
         'Page.getOriginTrials': {
             paramsType: [Protocol.Page.GetOriginTrialsRequest];
@@ -4229,6 +4923,8 @@ export namespace ProtocolMapping {
          * Overrides the values of device screen dimensions (window.screen.width, window.screen.height,
          * window.innerWidth, window.innerHeight, and "device-width"/"device-height"-related CSS media
          * query results).
+         * @deprecated
+         * @experimental
          */
         'Page.setDeviceMetricsOverride': {
             paramsType: [Protocol.Page.SetDeviceMetricsOverrideRequest];
@@ -4236,6 +4932,8 @@ export namespace ProtocolMapping {
         };
         /**
          * Overrides the Device Orientation.
+         * @deprecated
+         * @experimental
          */
         'Page.setDeviceOrientationOverride': {
             paramsType: [Protocol.Page.SetDeviceOrientationOverrideRequest];
@@ -4243,6 +4941,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Set generic font families.
+         * @experimental
          */
         'Page.setFontFamilies': {
             paramsType: [Protocol.Page.SetFontFamiliesRequest];
@@ -4250,6 +4949,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Set default font sizes.
+         * @experimental
          */
         'Page.setFontSizes': {
             paramsType: [Protocol.Page.SetFontSizesRequest];
@@ -4264,6 +4964,8 @@ export namespace ProtocolMapping {
         };
         /**
          * Set the behavior when downloading a file.
+         * @deprecated
+         * @experimental
          */
         'Page.setDownloadBehavior': {
             paramsType: [Protocol.Page.SetDownloadBehaviorRequest];
@@ -4272,6 +4974,7 @@ export namespace ProtocolMapping {
         /**
          * Overrides the Geolocation Position or Error. Omitting any of the parameters emulates position
          * unavailable.
+         * @deprecated
          */
         'Page.setGeolocationOverride': {
             paramsType: [Protocol.Page.SetGeolocationOverrideRequest?];
@@ -4286,6 +4989,8 @@ export namespace ProtocolMapping {
         };
         /**
          * Toggles mouse event-based touch event emulation.
+         * @deprecated
+         * @experimental
          */
         'Page.setTouchEmulationEnabled': {
             paramsType: [Protocol.Page.SetTouchEmulationEnabledRequest];
@@ -4293,6 +4998,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Starts sending each frame using the `screencastFrame` event.
+         * @experimental
          */
         'Page.startScreencast': {
             paramsType: [Protocol.Page.StartScreencastRequest?];
@@ -4307,6 +5013,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Crashes renderer on the IO thread, generates minidumps.
+         * @experimental
          */
         'Page.crash': {
             paramsType: [];
@@ -4323,6 +5030,7 @@ export namespace ProtocolMapping {
          * Tries to update the web lifecycle state of the page.
          * It will transition the page to the given state according to:
          * https://github.com/WICG/web-lifecycle/
+         * @experimental
          */
         'Page.setWebLifecycleState': {
             paramsType: [Protocol.Page.SetWebLifecycleStateRequest];
@@ -4330,6 +5038,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Stops sending each frame in the `screencastFrame`.
+         * @experimental
          */
         'Page.stopScreencast': {
             paramsType: [];
@@ -4342,6 +5051,7 @@ export namespace ProtocolMapping {
          * When script with a matching URL is encountered, the cache is optionally
          * produced upon backend discretion, based on internal heuristics.
          * See also: `Page.compilationCacheProduced`.
+         * @experimental
          */
         'Page.produceCompilationCache': {
             paramsType: [Protocol.Page.ProduceCompilationCacheRequest];
@@ -4350,6 +5060,7 @@ export namespace ProtocolMapping {
         /**
          * Seeds compilation cache for given url. Compilation cache does not survive
          * cross-process navigation.
+         * @experimental
          */
         'Page.addCompilationCache': {
             paramsType: [Protocol.Page.AddCompilationCacheRequest];
@@ -4357,6 +5068,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Clears seeded compilation cache.
+         * @experimental
          */
         'Page.clearCompilationCache': {
             paramsType: [];
@@ -4365,6 +5077,7 @@ export namespace ProtocolMapping {
         /**
          * Sets the Secure Payment Confirmation transaction mode.
          * https://w3c.github.io/secure-payment-confirmation/#sctn-automation-set-spc-transaction-mode
+         * @experimental
          */
         'Page.setSPCTransactionMode': {
             paramsType: [Protocol.Page.SetSPCTransactionModeRequest];
@@ -4373,6 +5086,7 @@ export namespace ProtocolMapping {
         /**
          * Extensions for Custom Handlers API:
          * https://html.spec.whatwg.org/multipage/system-state.html#rph-automation
+         * @experimental
          */
         'Page.setRPHRegistrationMode': {
             paramsType: [Protocol.Page.SetRPHRegistrationModeRequest];
@@ -4380,6 +5094,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Generates a report for testing.
+         * @experimental
          */
         'Page.generateTestReport': {
             paramsType: [Protocol.Page.GenerateTestReportRequest];
@@ -4387,6 +5102,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Pauses page execution. Can be resumed using generic Runtime.runIfWaitingForDebugger.
+         * @experimental
          */
         'Page.waitForDebugger': {
             paramsType: [];
@@ -4409,6 +5125,7 @@ export namespace ProtocolMapping {
          * for more details.
          * 
          * TODO(https://crbug.com/1440085): Remove this once Puppeteer supports tab targets.
+         * @experimental
          */
         'Page.setPrerenderingAllowed': {
             paramsType: [Protocol.Page.SetPrerenderingAllowedRequest];
@@ -4432,6 +5149,8 @@ export namespace ProtocolMapping {
          * Sets time domain to use for collecting and reporting duration metrics.
          * Note that this must be called before enabling metrics collection. Calling
          * this method while metrics collection is enabled returns an error.
+         * @deprecated
+         * @experimental
          */
         'Performance.setTimeDomain': {
             paramsType: [Protocol.Performance.SetTimeDomainRequest];
@@ -4452,6 +5171,14 @@ export namespace ProtocolMapping {
             paramsType: [Protocol.PerformanceTimeline.EnableRequest];
             returnType: void;
         };
+        'Preload.enable': {
+            paramsType: [];
+            returnType: void;
+        };
+        'Preload.disable': {
+            paramsType: [];
+            returnType: void;
+        };
         /**
          * Disables tracking security state changes.
          */
@@ -4475,6 +5202,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Handles a certificate error that fired a certificateError event.
+         * @deprecated
          */
         'Security.handleCertificateError': {
             paramsType: [Protocol.Security.HandleCertificateErrorRequest];
@@ -4483,6 +5211,7 @@ export namespace ProtocolMapping {
         /**
          * Enable/disable overriding certificate errors. If enabled, all certificate error events need to
          * be handled by the DevTools client and should be answered with `handleCertificateError` commands.
+         * @deprecated
          */
         'Security.setOverrideCertificateErrors': {
             paramsType: [Protocol.Security.SetOverrideCertificateErrorsRequest];
@@ -4587,6 +5316,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Override quota for the specified origin
+         * @experimental
          */
         'Storage.overrideQuotaForOrigin': {
             paramsType: [Protocol.Storage.OverrideQuotaForOriginRequest];
@@ -4651,6 +5381,7 @@ export namespace ProtocolMapping {
         /**
          * Returns the number of stored Trust Tokens per issuer for the
          * current browsing context.
+         * @experimental
          */
         'Storage.getTrustTokens': {
             paramsType: [];
@@ -4659,6 +5390,7 @@ export namespace ProtocolMapping {
         /**
          * Removes all Trust Tokens issued by the provided issuerOrigin.
          * Leaves other stored data, including the issuer's Redemption Records, intact.
+         * @experimental
          */
         'Storage.clearTrustTokens': {
             paramsType: [Protocol.Storage.ClearTrustTokensRequest];
@@ -4666,6 +5398,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Gets details for a named interest group.
+         * @experimental
          */
         'Storage.getInterestGroupDetails': {
             paramsType: [Protocol.Storage.GetInterestGroupDetailsRequest];
@@ -4673,6 +5406,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Enables/Disables issuing of interestGroupAccessed events.
+         * @experimental
          */
         'Storage.setInterestGroupTracking': {
             paramsType: [Protocol.Storage.SetInterestGroupTrackingRequest];
@@ -4681,6 +5415,7 @@ export namespace ProtocolMapping {
         /**
          * Enables/Disables issuing of interestGroupAuctionEventOccurred and
          * interestGroupAuctionNetworkRequestCreated.
+         * @experimental
          */
         'Storage.setInterestGroupAuctionTracking': {
             paramsType: [Protocol.Storage.SetInterestGroupAuctionTrackingRequest];
@@ -4688,6 +5423,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Gets metadata for an origin's shared storage.
+         * @experimental
          */
         'Storage.getSharedStorageMetadata': {
             paramsType: [Protocol.Storage.GetSharedStorageMetadataRequest];
@@ -4695,6 +5431,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Gets the entries in an given origin's shared storage.
+         * @experimental
          */
         'Storage.getSharedStorageEntries': {
             paramsType: [Protocol.Storage.GetSharedStorageEntriesRequest];
@@ -4702,6 +5439,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Sets entry with `key` and `value` for a given origin's shared storage.
+         * @experimental
          */
         'Storage.setSharedStorageEntry': {
             paramsType: [Protocol.Storage.SetSharedStorageEntryRequest];
@@ -4709,6 +5447,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Deletes entry for `key` (if it exists) for a given origin's shared storage.
+         * @experimental
          */
         'Storage.deleteSharedStorageEntry': {
             paramsType: [Protocol.Storage.DeleteSharedStorageEntryRequest];
@@ -4716,6 +5455,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Clears all entries for a given origin's shared storage.
+         * @experimental
          */
         'Storage.clearSharedStorageEntries': {
             paramsType: [Protocol.Storage.ClearSharedStorageEntriesRequest];
@@ -4723,6 +5463,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Resets the budget for `ownerOrigin` by clearing all budget withdrawals.
+         * @experimental
          */
         'Storage.resetSharedStorageBudget': {
             paramsType: [Protocol.Storage.ResetSharedStorageBudgetRequest];
@@ -4730,6 +5471,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Enables/disables issuing of sharedStorageAccessed events.
+         * @experimental
          */
         'Storage.setSharedStorageTracking': {
             paramsType: [Protocol.Storage.SetSharedStorageTrackingRequest];
@@ -4737,6 +5479,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Set tracking for a storage key's buckets.
+         * @experimental
          */
         'Storage.setStorageBucketTracking': {
             paramsType: [Protocol.Storage.SetStorageBucketTrackingRequest];
@@ -4744,6 +5487,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Deletes the Storage Bucket with the given storage key and bucket name.
+         * @experimental
          */
         'Storage.deleteStorageBucket': {
             paramsType: [Protocol.Storage.DeleteStorageBucketRequest];
@@ -4751,6 +5495,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Deletes state for sites identified as potential bounce trackers, immediately.
+         * @experimental
          */
         'Storage.runBounceTrackingMitigations': {
             paramsType: [];
@@ -4758,6 +5503,7 @@ export namespace ProtocolMapping {
         };
         /**
          * https://wicg.github.io/attribution-reporting-api/
+         * @experimental
          */
         'Storage.setAttributionReportingLocalTestingMode': {
             paramsType: [Protocol.Storage.SetAttributionReportingLocalTestingModeRequest];
@@ -4765,6 +5511,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Enables/disables issuing of Attribution Reporting events.
+         * @experimental
          */
         'Storage.setAttributionReportingTracking': {
             paramsType: [Protocol.Storage.SetAttributionReportingTrackingRequest];
@@ -4773,6 +5520,7 @@ export namespace ProtocolMapping {
         /**
          * Sends all pending Attribution Reports immediately, regardless of their
          * scheduled report time.
+         * @experimental
          */
         'Storage.sendPendingAttributionReports': {
             paramsType: [];
@@ -4781,6 +5529,7 @@ export namespace ProtocolMapping {
         /**
          * Returns the effective Related Website Sets in use by this profile for the browser
          * session. The effective Related Website Sets will not change during a browser session.
+         * @experimental
          */
         'Storage.getRelatedWebsiteSets': {
             paramsType: [];
@@ -4790,6 +5539,7 @@ export namespace ProtocolMapping {
          * Returns the list of URLs from a page and its embedded resources that match
          * existing grace period URL pattern rules.
          * https://developers.google.com/privacy-sandbox/cookies/temporary-exceptions/grace-period
+         * @experimental
          */
         'Storage.getAffectedUrlsForThirdPartyCookieMetadata': {
             paramsType: [Protocol.Storage.GetAffectedUrlsForThirdPartyCookieMetadataRequest];
@@ -4836,6 +5586,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Attaches to the browser target, only uses flat sessionId mode.
+         * @experimental
          */
         'Target.attachToBrowserTarget': {
             paramsType: [];
@@ -4857,6 +5608,7 @@ export namespace ProtocolMapping {
          * The object has the following API:
          * - `binding.send(json)` - a method to send messages over the remote debugging protocol
          * - `binding.onmessage = json => handleMessage(json)` - a callback that will be called for the protocol notifications and command responses.
+         * @experimental
          */
         'Target.exposeDevToolsProtocol': {
             paramsType: [Protocol.Target.ExposeDevToolsProtocolRequest];
@@ -4901,6 +5653,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Returns information about a target.
+         * @experimental
          */
         'Target.getTargetInfo': {
             paramsType: [Protocol.Target.GetTargetInfoRequest?];
@@ -4917,6 +5670,7 @@ export namespace ProtocolMapping {
          * Sends protocol message over session with given id.
          * Consider using flat mode instead; see commands attachToTarget, setAutoAttach,
          * and crbug.com/991325.
+         * @deprecated
          */
         'Target.sendMessageToTarget': {
             paramsType: [Protocol.Target.SendMessageToTargetRequest];
@@ -4942,6 +5696,7 @@ export namespace ProtocolMapping {
          * through `attachedToTarget`. The specified target is also auto-attached.
          * This cancels the effect of any previous `setAutoAttach` and is also cancelled by subsequent
          * `setAutoAttach`. Only available at the Browser target.
+         * @experimental
          */
         'Target.autoAttachRelated': {
             paramsType: [Protocol.Target.AutoAttachRelatedRequest];
@@ -4958,6 +5713,7 @@ export namespace ProtocolMapping {
         /**
          * Enables target discovery for the specified locations, when `setDiscoverTargets` was set to
          * `true`.
+         * @experimental
          */
         'Target.setRemoteLocations': {
             paramsType: [Protocol.Target.SetRemoteLocationsRequest];
@@ -4965,6 +5721,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Opens a DevTools window for the target.
+         * @experimental
          */
         'Target.openDevTools': {
             paramsType: [Protocol.Target.OpenDevToolsRequest];
@@ -4993,6 +5750,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Gets supported tracing categories.
+         * @experimental
          */
         'Tracing.getCategories': {
             paramsType: [];
@@ -5000,6 +5758,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Record a clock sync marker in the trace.
+         * @experimental
          */
         'Tracing.recordClockSyncMarker': {
             paramsType: [Protocol.Tracing.RecordClockSyncMarkerRequest];
@@ -5007,6 +5766,7 @@ export namespace ProtocolMapping {
         };
         /**
          * Request a global memory dump.
+         * @experimental
          */
         'Tracing.requestMemoryDump': {
             paramsType: [Protocol.Tracing.RequestMemoryDumpRequest?];
@@ -5019,90 +5779,6 @@ export namespace ProtocolMapping {
             paramsType: [Protocol.Tracing.StartRequest?];
             returnType: void;
         };
-        /**
-         * Disables the fetch domain.
-         */
-        'Fetch.disable': {
-            paramsType: [];
-            returnType: void;
-        };
-        /**
-         * Enables issuing of requestPaused events. A request will be paused until client
-         * calls one of failRequest, fulfillRequest or continueRequest/continueWithAuth.
-         */
-        'Fetch.enable': {
-            paramsType: [Protocol.Fetch.EnableRequest?];
-            returnType: void;
-        };
-        /**
-         * Causes the request to fail with specified reason.
-         */
-        'Fetch.failRequest': {
-            paramsType: [Protocol.Fetch.FailRequestRequest];
-            returnType: void;
-        };
-        /**
-         * Provides response to the request.
-         */
-        'Fetch.fulfillRequest': {
-            paramsType: [Protocol.Fetch.FulfillRequestRequest];
-            returnType: void;
-        };
-        /**
-         * Continues the request, optionally modifying some of its parameters.
-         */
-        'Fetch.continueRequest': {
-            paramsType: [Protocol.Fetch.ContinueRequestRequest];
-            returnType: void;
-        };
-        /**
-         * Continues a request supplying authChallengeResponse following authRequired event.
-         */
-        'Fetch.continueWithAuth': {
-            paramsType: [Protocol.Fetch.ContinueWithAuthRequest];
-            returnType: void;
-        };
-        /**
-         * Continues loading of the paused response, optionally modifying the
-         * response headers. If either responseCode or headers are modified, all of them
-         * must be present.
-         */
-        'Fetch.continueResponse': {
-            paramsType: [Protocol.Fetch.ContinueResponseRequest];
-            returnType: void;
-        };
-        /**
-         * 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.
-         */
-        'Fetch.getResponseBody': {
-            paramsType: [Protocol.Fetch.GetResponseBodyRequest];
-            returnType: Protocol.Fetch.GetResponseBodyResponse;
-        };
-        /**
-         * 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.
-         */
-        'Fetch.takeResponseBodyAsStream': {
-            paramsType: [Protocol.Fetch.TakeResponseBodyAsStreamRequest];
-            returnType: Protocol.Fetch.TakeResponseBodyAsStreamResponse;
-        };
         /**
          * Enables the WebAudio domain and starts sending context lifetime events.
          */
@@ -5220,305 +5896,6 @@ export namespace ProtocolMapping {
             paramsType: [Protocol.WebAuthn.SetCredentialPropertiesRequest];
             returnType: void;
         };
-        /**
-         * Enables the Media domain
-         */
-        'Media.enable': {
-            paramsType: [];
-            returnType: void;
-        };
-        /**
-         * Disables the Media domain.
-         */
-        'Media.disable': {
-            paramsType: [];
-            returnType: void;
-        };
-        /**
-         * Enable events in this domain.
-         */
-        'DeviceAccess.enable': {
-            paramsType: [];
-            returnType: void;
-        };
-        /**
-         * Disable events in this domain.
-         */
-        'DeviceAccess.disable': {
-            paramsType: [];
-            returnType: void;
-        };
-        /**
-         * Select a device in response to a DeviceAccess.deviceRequestPrompted event.
-         */
-        'DeviceAccess.selectPrompt': {
-            paramsType: [Protocol.DeviceAccess.SelectPromptRequest];
-            returnType: void;
-        };
-        /**
-         * Cancel a prompt in response to a DeviceAccess.deviceRequestPrompted event.
-         */
-        'DeviceAccess.cancelPrompt': {
-            paramsType: [Protocol.DeviceAccess.CancelPromptRequest];
-            returnType: void;
-        };
-        'Preload.enable': {
-            paramsType: [];
-            returnType: void;
-        };
-        'Preload.disable': {
-            paramsType: [];
-            returnType: void;
-        };
-        'FedCm.enable': {
-            paramsType: [Protocol.FedCm.EnableRequest?];
-            returnType: void;
-        };
-        'FedCm.disable': {
-            paramsType: [];
-            returnType: void;
-        };
-        'FedCm.selectAccount': {
-            paramsType: [Protocol.FedCm.SelectAccountRequest];
-            returnType: void;
-        };
-        'FedCm.clickDialogButton': {
-            paramsType: [Protocol.FedCm.ClickDialogButtonRequest];
-            returnType: void;
-        };
-        'FedCm.openUrl': {
-            paramsType: [Protocol.FedCm.OpenUrlRequest];
-            returnType: void;
-        };
-        'FedCm.dismissDialog': {
-            paramsType: [Protocol.FedCm.DismissDialogRequest];
-            returnType: void;
-        };
-        /**
-         * 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.
-         */
-        'FedCm.resetCooldown': {
-            paramsType: [];
-            returnType: void;
-        };
-        /**
-         * Returns the following OS state for the given manifest id.
-         */
-        'PWA.getOsAppState': {
-            paramsType: [Protocol.PWA.GetOsAppStateRequest];
-            returnType: Protocol.PWA.GetOsAppStateResponse;
-        };
-        /**
-         * 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.
-         */
-        'PWA.install': {
-            paramsType: [Protocol.PWA.InstallRequest];
-            returnType: void;
-        };
-        /**
-         * Uninstalls the given manifest_id and closes any opened app windows.
-         */
-        'PWA.uninstall': {
-            paramsType: [Protocol.PWA.UninstallRequest];
-            returnType: void;
-        };
-        /**
-         * 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.
-         */
-        'PWA.launch': {
-            paramsType: [Protocol.PWA.LaunchRequest];
-            returnType: Protocol.PWA.LaunchResponse;
-        };
-        /**
-         * 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.
-         */
-        'PWA.launchFilesInApp': {
-            paramsType: [Protocol.PWA.LaunchFilesInAppRequest];
-            returnType: Protocol.PWA.LaunchFilesInAppResponse;
-        };
-        /**
-         * 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.
-         */
-        'PWA.openCurrentPageInApp': {
-            paramsType: [Protocol.PWA.OpenCurrentPageInAppRequest];
-            returnType: void;
-        };
-        /**
-         * 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.
-         */
-        'PWA.changeAppUserSettings': {
-            paramsType: [Protocol.PWA.ChangeAppUserSettingsRequest];
-            returnType: void;
-        };
-        /**
-         * Enable the BluetoothEmulation domain.
-         */
-        'BluetoothEmulation.enable': {
-            paramsType: [Protocol.BluetoothEmulation.EnableRequest];
-            returnType: void;
-        };
-        /**
-         * Set the state of the simulated central.
-         */
-        'BluetoothEmulation.setSimulatedCentralState': {
-            paramsType: [Protocol.BluetoothEmulation.SetSimulatedCentralStateRequest];
-            returnType: void;
-        };
-        /**
-         * Disable the BluetoothEmulation domain.
-         */
-        'BluetoothEmulation.disable': {
-            paramsType: [];
-            returnType: void;
-        };
-        /**
-         * Simulates a peripheral with |address|, |name| and |knownServiceUuids|
-         * that has already been connected to the system.
-         */
-        'BluetoothEmulation.simulatePreconnectedPeripheral': {
-            paramsType: [Protocol.BluetoothEmulation.SimulatePreconnectedPeripheralRequest];
-            returnType: void;
-        };
-        /**
-         * Simulates an advertisement packet described in |entry| being received by
-         * the central.
-         */
-        'BluetoothEmulation.simulateAdvertisement': {
-            paramsType: [Protocol.BluetoothEmulation.SimulateAdvertisementRequest];
-            returnType: void;
-        };
-        /**
-         * 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.
-         */
-        'BluetoothEmulation.simulateGATTOperationResponse': {
-            paramsType: [Protocol.BluetoothEmulation.SimulateGATTOperationResponseRequest];
-            returnType: void;
-        };
-        /**
-         * 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.
-         */
-        'BluetoothEmulation.simulateCharacteristicOperationResponse': {
-            paramsType: [Protocol.BluetoothEmulation.SimulateCharacteristicOperationResponseRequest];
-            returnType: void;
-        };
-        /**
-         * 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.
-         */
-        'BluetoothEmulation.simulateDescriptorOperationResponse': {
-            paramsType: [Protocol.BluetoothEmulation.SimulateDescriptorOperationResponseRequest];
-            returnType: void;
-        };
-        /**
-         * Adds a service with |serviceUuid| to the peripheral with |address|.
-         */
-        'BluetoothEmulation.addService': {
-            paramsType: [Protocol.BluetoothEmulation.AddServiceRequest];
-            returnType: Protocol.BluetoothEmulation.AddServiceResponse;
-        };
-        /**
-         * Removes the service respresented by |serviceId| from the simulated central.
-         */
-        'BluetoothEmulation.removeService': {
-            paramsType: [Protocol.BluetoothEmulation.RemoveServiceRequest];
-            returnType: void;
-        };
-        /**
-         * Adds a characteristic with |characteristicUuid| and |properties| to the
-         * service represented by |serviceId|.
-         */
-        'BluetoothEmulation.addCharacteristic': {
-            paramsType: [Protocol.BluetoothEmulation.AddCharacteristicRequest];
-            returnType: Protocol.BluetoothEmulation.AddCharacteristicResponse;
-        };
-        /**
-         * Removes the characteristic respresented by |characteristicId| from the
-         * simulated central.
-         */
-        'BluetoothEmulation.removeCharacteristic': {
-            paramsType: [Protocol.BluetoothEmulation.RemoveCharacteristicRequest];
-            returnType: void;
-        };
-        /**
-         * Adds a descriptor with |descriptorUuid| to the characteristic respresented
-         * by |characteristicId|.
-         */
-        'BluetoothEmulation.addDescriptor': {
-            paramsType: [Protocol.BluetoothEmulation.AddDescriptorRequest];
-            returnType: Protocol.BluetoothEmulation.AddDescriptorResponse;
-        };
-        /**
-         * Removes the descriptor with |descriptorId| from the simulated central.
-         */
-        'BluetoothEmulation.removeDescriptor': {
-            paramsType: [Protocol.BluetoothEmulation.RemoveDescriptorRequest];
-            returnType: void;
-        };
-        /**
-         * Simulates a GATT disconnection from the peripheral with |address|.
-         */
-        'BluetoothEmulation.simulateGATTDisconnection': {
-            paramsType: [Protocol.BluetoothEmulation.SimulateGATTDisconnectionRequest];
-            returnType: void;
-        };
     }
 }