// Copyright (c) 2026 The Chromium Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

/**********************************************************************

* Auto-generated by protocol-dts-generator.ts. Do not edit manually. *

**********************************************************************/

import Protocol from './protocol'

/**

* Mappings from protocol event and command names to the types required for them.

*/

export namespace ProtocolMapping {

export interface Events {

/**

* Issued when new console message is added.

*/

'Console.messageAdded': [Protocol.Console.MessageAddedEvent];

/**

* 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];

/**

* Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.

*/

'Debugger.paused': [Protocol.Debugger.PausedEvent];

/**

* Fired when the virtual machine resumed execution.

*/

'Debugger.resumed': [];

/**

* Fired when virtual machine fails to parse the script.

*/

'Debugger.scriptFailedToParse': [Protocol.Debugger.ScriptFailedToParseEvent];

/**

* Fired when virtual machine parses script. This event is also fired for all known and uncollected

* scripts upon enabling debugger.

*/

'Debugger.scriptParsed': [Protocol.Debugger.ScriptParsedEvent];

'HeapProfiler.addHeapSnapshotChunk': [Protocol.HeapProfiler.AddHeapSnapshotChunkEvent];

/**

* If heap objects tracking has been started then backend may send update for one or more fragments

*/

'HeapProfiler.heapStatsUpdate': [Protocol.HeapProfiler.HeapStatsUpdateEvent];

/**

* If heap objects tracking has been started then backend regularly sends a current value for last

* seen object id and corresponding timestamp. If the were changes in the heap since last event

* then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.

*/

'HeapProfiler.lastSeenObjectId': [Protocol.HeapProfiler.LastSeenObjectIdEvent];

'HeapProfiler.reportHeapSnapshotProgress': [Protocol.HeapProfiler.ReportHeapSnapshotProgressEvent];

'HeapProfiler.resetProfiles': [];

'Profiler.consoleProfileFinished': [Protocol.Profiler.ConsoleProfileFinishedEvent];

/**

* Sent when new profile recording is started using console.profile() call.

*/

'Profiler.consoleProfileStarted': [Protocol.Profiler.ConsoleProfileStartedEvent];

/**

* Reports coverage delta since the last poll (either from an event like this, or from

* `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];

/**

* Issued when console API was called.

*/

'Runtime.consoleAPICalled': [Protocol.Runtime.ConsoleAPICalledEvent];

/**

* Issued when unhandled exception was revoked.

*/

'Runtime.exceptionRevoked': [Protocol.Runtime.ExceptionRevokedEvent];

/**

* Issued when exception was thrown and unhandled.

*/

'Runtime.exceptionThrown': [Protocol.Runtime.ExceptionThrownEvent];

/**

* Issued when new execution context is created.

*/

'Runtime.executionContextCreated': [Protocol.Runtime.ExecutionContextCreatedEvent];

/**

* Issued when execution context is destroyed.

*/

'Runtime.executionContextDestroyed': [Protocol.Runtime.ExecutionContextDestroyedEvent];

/**

* Issued when all executionContexts were cleared in browser

*/

'Runtime.executionContextsCleared': [];

/**

* Issued when object should be inspected (for example, as a result of inspect() command line API

* call).

*/

'Runtime.inspectRequested': [Protocol.Runtime.InspectRequestedEvent];

/**

* 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];

/**

* Event for when an animation has been cancelled.

*/

'Animation.animationCanceled': [Protocol.Animation.AnimationCanceledEvent];

/**

* Event for each animation that has been created.

*/

'Animation.animationCreated': [Protocol.Animation.AnimationCreatedEvent];

/**

* Event for animation that has been started.

*/

'Animation.animationStarted': [Protocol.Animation.AnimationStartedEvent];

/**

* Event for animation that has been updated.

*/

'Animation.animationUpdated': [Protocol.Animation.AnimationUpdatedEvent];

'Audits.issueAdded': [Protocol.Audits.IssueAddedEvent];

/**

* Emitted when an address form is filled.

*/

'Autofill.addressFormFilled': [Protocol.Autofill.AddressFormFilledEvent];

/**

* Called when the recording state for the service has been updated.

*/

'BackgroundService.recordingStateChanged': [Protocol.BackgroundService.RecordingStateChangedEvent];

/**

* Called with all existing backgroundServiceEvents when enabled, and all new

* 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];

/**

* Fires whenever a web font is updated. A non-empty font parameter indicates a successfully loaded

* web font.

*/

'CSS.fontsUpdated': [Protocol.CSS.FontsUpdatedEvent];

/**

* Fires whenever a MediaQuery result changes (for example, after a browser window has been

* resized.) The current implementation considers only viewport-dependent media features.

*/

'CSS.mediaQueryResultChanged': [];

/**

* Fired whenever an active document stylesheet is added.

*/

'CSS.styleSheetAdded': [Protocol.CSS.StyleSheetAddedEvent];

/**

* Fired whenever a stylesheet is changed as a result of the client operation.

*/

'CSS.styleSheetChanged': [Protocol.CSS.StyleSheetChangedEvent];

/**

* 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

* device or a software surface that you can cast to.

*/

'Cast.sinksUpdated': [Protocol.Cast.SinksUpdatedEvent];

/**

* This is fired whenever the outstanding issue/error message changes.

* |issueMessage| is empty if there is no issue.

*/

'Cast.issueUpdated': [Protocol.Cast.IssueUpdatedEvent];

/**

* Fired when `Element`'s attribute is modified.

*/

'DOM.attributeModified': [Protocol.DOM.AttributeModifiedEvent];

/**

* Fired when `Element`'s adoptedStyleSheets are modified.

* @experimental

*/

'DOM.adoptedStyleSheetsModified': [Protocol.DOM.AdoptedStyleSheetsModifiedEvent];

/**

* Fired when `Element`'s attribute is removed.

*/

'DOM.attributeRemoved': [Protocol.DOM.AttributeRemovedEvent];

/**

* Mirrors `DOMCharacterDataModified` event.

*/

'DOM.characterDataModified': [Protocol.DOM.CharacterDataModifiedEvent];

/**

* Fired when `Container`'s child node count has changed.

*/

'DOM.childNodeCountUpdated': [Protocol.DOM.ChildNodeCountUpdatedEvent];

/**

* Mirrors `DOMNodeInserted` event.

*/

'DOM.childNodeInserted': [Protocol.DOM.ChildNodeInsertedEvent];

/**

* Mirrors `DOMNodeRemoved` event.

*/

'DOM.childNodeRemoved': [Protocol.DOM.ChildNodeRemovedEvent];

/**

* Called when distribution is changed.

* @experimental

*/

'DOM.distributedNodesUpdated': [Protocol.DOM.DistributedNodesUpdatedEvent];

/**

* Fired when `Document` has been totally updated. Node ids are no longer valid.

*/

'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];

/**

* Fired when a node's ad related state changes.

* @experimental

*/

'DOM.adRelatedStateUpdated': [Protocol.DOM.AdRelatedStateUpdatedEvent];

/**

* Fired when a node's starting styles changes.

* @experimental

*/

'DOM.affectedByStartingStylesFlagUpdated': [Protocol.DOM.AffectedByStartingStylesFlagUpdatedEvent];

/**

* Called when a pseudo element is removed from an element.

* @experimental

*/

'DOM.pseudoElementRemoved': [Protocol.DOM.PseudoElementRemovedEvent];

/**

* Fired when backend wants to provide client with the missing DOM structure. This happens upon

* most of the calls requesting node ids.

*/

'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': [];

/**

* Fired when a page calls screen.orientation.lock() or screen.orientation.unlock()

* while device emulation is enabled. This allows the DevTools frontend to update the

* emulated device orientation accordingly.

* @experimental

*/

'Emulation.screenOrientationLockChanged': [Protocol.Emulation.ScreenOrientationLockChangedEvent];

'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];

/**

* Fired when remote debugging connection is about to be terminated. Contains detach reason.

*/

'Inspector.detached': [Protocol.Inspector.DetachedEvent];

/**

* Fired when debugging target has crashed

*/

'Inspector.targetCrashed': [];

/**

* Fired when debugging target has reloaded after crash

*/

'Inspector.targetReloadedAfterCrash': [];

/**

* Fired on worker targets when main worker script and any imported scripts have been evaluated.

* @experimental

*/

'Inspector.workerScriptLoaded': [];

'LayerTree.layerPainted': [Protocol.LayerTree.LayerPaintedEvent];

'LayerTree.layerTreeDidChange': [Protocol.LayerTree.LayerTreeDidChangeEvent];

/**

* 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 one

* event for each active player.

*/

'Media.playerCreated': [Protocol.Media.PlayerCreatedEvent];

/**

* Fired when data chunk was received over the network.

*/

'Network.dataReceived': [Protocol.Network.DataReceivedEvent];

/**

* Fired when EventSource message is received.

*/

'Network.eventSourceMessageReceived': [Protocol.Network.EventSourceMessageReceivedEvent];

/**

* Fired when HTTP request has failed to load.

*/

'Network.loadingFailed': [Protocol.Network.LoadingFailedEvent];

/**

* Fired when HTTP request has finished loading.

*/

'Network.loadingFinished': [Protocol.Network.LoadingFinishedEvent];

/**

* 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];

/**

* Fired if request ended up loading from cache.

*/

'Network.requestServedFromCache': [Protocol.Network.RequestServedFromCacheEvent];

/**

* Fired when page is about to send HTTP request.

*/

'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];

/**

* Fired when HTTP response is available.

*/

'Network.responseReceived': [Protocol.Network.ResponseReceivedEvent];

/**

* Fired when WebSocket is closed.

*/

'Network.webSocketClosed': [Protocol.Network.WebSocketClosedEvent];

/**

* Fired upon WebSocket creation.

*/

'Network.webSocketCreated': [Protocol.Network.WebSocketCreatedEvent];

/**

* Fired when WebSocket message error occurs.

*/

'Network.webSocketFrameError': [Protocol.Network.WebSocketFrameErrorEvent];

/**

* Fired when WebSocket message is received.

*/

'Network.webSocketFrameReceived': [Protocol.Network.WebSocketFrameReceivedEvent];

/**

* Fired when WebSocket message is sent.

*/

'Network.webSocketFrameSent': [Protocol.Network.WebSocketFrameSentEvent];

/**

* Fired when WebSocket handshake response becomes available.

*/

'Network.webSocketHandshakeResponseReceived': [Protocol.Network.WebSocketHandshakeResponseReceivedEvent];

/**

* Fired when WebSocket is about to initiate handshake.

*/

'Network.webSocketWillSendHandshakeRequest': [Protocol.Network.WebSocketWillSendHandshakeRequestEvent];

/**

* Fired upon WebTransport creation.

*/

'Network.webTransportCreated': [Protocol.Network.WebTransportCreatedEvent];

/**

* Fired when WebTransport handshake is finished.

*/

'Network.webTransportConnectionEstablished': [Protocol.Network.WebTransportConnectionEstablishedEvent];

/**

* Fired when WebTransport is disposed.

*/

'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];

/**

* @experimental

*/

'Network.directUDPSocketJoinedMulticastGroup': [Protocol.Network.DirectUDPSocketJoinedMulticastGroupEvent];

/**

* @experimental

*/

'Network.directUDPSocketLeftMulticastGroup': [Protocol.Network.DirectUDPSocketLeftMulticastGroupEvent];

/**

* 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];

/**

* Fired when additional information about a requestWillBeSent event is available from the

* 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];

/**

* Fired exactly once for each Trust Token operation. Depending on

* 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': [];

/**

* 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];

/**

* Triggered when the initial set of device bound sessions is added.

* @experimental

*/

'Network.deviceBoundSessionsAdded': [Protocol.Network.DeviceBoundSessionsAddedEvent];

/**

* Triggered when a device bound session event occurs.

* @experimental

*/

'Network.deviceBoundSessionEventOccurred': [Protocol.Network.DeviceBoundSessionEventOccurredEvent];

/**

* Fired when the node should be inspected. This happens after call to `setInspectMode` or when

* user manually inspects an element.

*/

'Overlay.inspectNodeRequested': [Protocol.Overlay.InspectNodeRequestedEvent];

/**

* Fired when the node should be highlighted. This happens after call to `setInspectMode`.

*/

'Overlay.nodeHighlightRequested': [Protocol.Overlay.NodeHighlightRequestedEvent];

/**

* Fired when user asks to capture screenshot of some area on the page.

*/

'Overlay.screenshotRequested': [Protocol.Overlay.ScreenshotRequestedEvent];

/**

* Fired when user asks to show the Inspect panel.

*/

'Overlay.inspectPanelShowRequested': [Protocol.Overlay.InspectPanelShowRequestedEvent];

/**

* Fired when user asks to restore the Inspected Element floating window.

*/

'Overlay.inspectedElementWindowRestored': [Protocol.Overlay.InspectedElementWindowRestoredEvent];

/**

* Fired when user cancels the inspect mode.

*/

'Overlay.inspectModeCanceled': [];

'Page.domContentEventFired': [Protocol.Page.DomContentEventFiredEvent];

/**

* Emitted only when `page.interceptFileChooser` is enabled.

*/

'Page.fileChooserOpened': [Protocol.Page.FileChooserOpenedEvent];

/**

* Fired when frame has been attached to its parent.

*/

'Page.frameAttached': [Protocol.Page.FrameAttachedEvent];

/**

* Fired when frame no longer has a scheduled navigation.

* @deprecated

*/

'Page.frameClearedScheduledNavigation': [Protocol.Page.FrameClearedScheduledNavigationEvent];

/**

* Fired when frame has been detached from its parent.

*/

'Page.frameDetached': [Protocol.Page.FrameDetachedEvent];

/**

* Fired before frame subtree is detached. Emitted before any frame of the

* subtree is actually detached.

* @experimental

*/

'Page.frameSubtreeWillBeDetached': [Protocol.Page.FrameSubtreeWillBeDetachedEvent];

/**

* Fired once navigation of the frame has completed. Frame is now associated with the new loader.

*/

'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

* renderer-initiated and browser-initiated navigations. For renderer-initiated

* navigations, the event is fired after `frameRequestedNavigation`.

* Navigation may still be cancelled after the event is issued. Multiple events

* 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];

/**

* Fired when interstitial page was hidden

*/

'Page.interstitialHidden': [];

/**

* Fired when interstitial page was shown

*/

'Page.interstitialShown': [];

/**

* Fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) has been

* closed.

*/

'Page.javascriptDialogClosed': [Protocol.Page.JavascriptDialogClosedEvent];

/**

* Fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) is about to

* open.

*/

'Page.javascriptDialogOpening': [Protocol.Page.JavascriptDialogOpeningEvent];

/**

* Fired for lifecycle events (navigation, load, paint, etc) in the current

* target (including local frames).

*/

'Page.lifecycleEvent': [Protocol.Page.LifecycleEventEvent];

/**

* Fired for failed bfcache history navigations if BackForwardCache feature is enabled. Do

* 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];

/**

* Fired when a new window is going to be opened, via window.open(), link click, form submission,

* etc.

*/

'Page.windowOpen': [Protocol.Page.WindowOpenEvent];

/**

* Issued for every compilation cache generated.

* @experimental

*/

'Page.compilationCacheProduced': [Protocol.Page.CompilationCacheProducedEvent];

/**

* Current values of the metrics.

*/

'Performance.metrics': [Protocol.Performance.MetricsEvent];

/**

* 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];

'ServiceWorker.workerRegistrationUpdated': [Protocol.ServiceWorker.WorkerRegistrationUpdatedEvent];

'ServiceWorker.workerVersionUpdated': [Protocol.ServiceWorker.WorkerVersionUpdatedEvent];

/**

* Fired when |SCardEstablishContext| is called.

*

* This maps to:

* PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#gaa1b8970169fd4883a6dc4a8f43f19b67

* Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardestablishcontext

*/

'SmartCardEmulation.establishContextRequested': [Protocol.SmartCardEmulation.EstablishContextRequestedEvent];

/**

* Fired when |SCardReleaseContext| is called.

*

* This maps to:

* PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#ga6aabcba7744c5c9419fdd6404f73a934

* Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardreleasecontext

*/

'SmartCardEmulation.releaseContextRequested': [Protocol.SmartCardEmulation.ReleaseContextRequestedEvent];

/**

* Fired when |SCardListReaders| is called.

*

* This maps to:

* PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#ga93b07815789b3cf2629d439ecf20f0d9

* Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardlistreadersa

*/

'SmartCardEmulation.listReadersRequested': [Protocol.SmartCardEmulation.ListReadersRequestedEvent];

/**

* Fired when |SCardGetStatusChange| is called. Timeout is specified in milliseconds.

*

* This maps to:

* PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#ga33247d5d1257d59e55647c3bb717db24

* Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardgetstatuschangea

*/

'SmartCardEmulation.getStatusChangeRequested': [Protocol.SmartCardEmulation.GetStatusChangeRequestedEvent];

/**

* Fired when |SCardCancel| is called.

*

* This maps to:

* PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#gaacbbc0c6d6c0cbbeb4f4debf6fbeeee6

* Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardcancel

*/

'SmartCardEmulation.cancelRequested': [Protocol.SmartCardEmulation.CancelRequestedEvent];

/**

* Fired when |SCardConnect| is called.

*

* This maps to:

* PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#ga4e515829752e0a8dbc4d630696a8d6a5

* Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardconnecta

*/

'SmartCardEmulation.connectRequested': [Protocol.SmartCardEmulation.ConnectRequestedEvent];

/**

* Fired when |SCardDisconnect| is called.

*

* This maps to:

* PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#ga4be198045c73ec0deb79e66c0ca1738a

* Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scarddisconnect

*/

'SmartCardEmulation.disconnectRequested': [Protocol.SmartCardEmulation.DisconnectRequestedEvent];

/**

* Fired when |SCardTransmit| is called.

*

* This maps to:

* PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#ga9a2d77242a271310269065e64633ab99

* Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardtransmit

*/

'SmartCardEmulation.transmitRequested': [Protocol.SmartCardEmulation.TransmitRequestedEvent];

/**

* Fired when |SCardControl| is called.

*

* This maps to:

* PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#gac3454d4657110fd7f753b2d3d8f4e32f

* Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardcontrol

*/

'SmartCardEmulation.controlRequested': [Protocol.SmartCardEmulation.ControlRequestedEvent];

/**

* Fired when |SCardGetAttrib| is called.

*

* This maps to:

* PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#gaacfec51917255b7a25b94c5104961602

* Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardgetattrib

*/

'SmartCardEmulation.getAttribRequested': [Protocol.SmartCardEmulation.GetAttribRequestedEvent];

/**

* Fired when |SCardSetAttrib| is called.

*

* This maps to:

* PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#ga060f0038a4ddfd5dd2b8fadf3c3a2e4f

* Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardsetattrib

*/

'SmartCardEmulation.setAttribRequested': [Protocol.SmartCardEmulation.SetAttribRequestedEvent];

/**

* Fired when |SCardStatus| is called.

*

* This maps to:

* PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#gae49c3c894ad7ac12a5b896bde70d0382

* Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardstatusa

*/

'SmartCardEmulation.statusRequested': [Protocol.SmartCardEmulation.StatusRequestedEvent];

/**

* Fired when |SCardBeginTransaction| is called.

*

* This maps to:

* PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#gaddb835dce01a0da1d6ca02d33ee7d861

* Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardbegintransaction

*/

'SmartCardEmulation.beginTransactionRequested': [Protocol.SmartCardEmulation.BeginTransactionRequestedEvent];

/**

* Fired when |SCardEndTransaction| is called.

*

* This maps to:

* PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#gae8742473b404363e5c587f570d7e2f3b

* Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardendtransaction

*/

'SmartCardEmulation.endTransactionRequested': [Protocol.SmartCardEmulation.EndTransactionRequestedEvent];

/**

* A cache's contents have been modified.

*/

'Storage.cacheStorageContentUpdated': [Protocol.Storage.CacheStorageContentUpdatedEvent];

/**

* A cache has been added/deleted.

*/

'Storage.cacheStorageListUpdated': [Protocol.Storage.CacheStorageListUpdatedEvent];

/**

* The origin's IndexedDB object store has been modified.

*/

'Storage.indexedDBContentUpdated': [Protocol.Storage.IndexedDBContentUpdatedEvent];

/**

* The origin's IndexedDB database list has been modified.

*/

'Storage.indexedDBListUpdated': [Protocol.Storage.IndexedDBListUpdatedEvent];

/**

* One of the interest groups was accessed. Note that these events are global

* to all targets sharing an interest group store.

*/

'Storage.interestGroupAccessed': [Protocol.Storage.InterestGroupAccessedEvent];

/**

* An auction involving interest groups is taking place. These events are

* target-specific.

*/

'Storage.interestGroupAuctionEventOccurred': [Protocol.Storage.InterestGroupAuctionEventOccurredEvent];

/**

* Specifies which auctions a particular network fetch may be related to, and

* in what role. Note that it is not ordered with respect to

* Network.requestWillBeSent (but will happen before loadingFinished

* loadingFailed).

*/

'Storage.interestGroupAuctionNetworkRequestCreated': [Protocol.Storage.InterestGroupAuctionNetworkRequestCreatedEvent];

/**

* Shared storage was accessed by the associated page.

* The following parameters are included in all events.

*/

'Storage.sharedStorageAccessed': [Protocol.Storage.SharedStorageAccessedEvent];

/**

* A shared storage run or selectURL operation finished its execution.

* The following parameters are included in all events.

*/

'Storage.sharedStorageWorkletOperationExecutionFinished': [Protocol.Storage.SharedStorageWorkletOperationExecutionFinishedEvent];

'Storage.storageBucketCreatedOrUpdated': [Protocol.Storage.StorageBucketCreatedOrUpdatedEvent];

'Storage.storageBucketDeleted': [Protocol.Storage.StorageBucketDeletedEvent];

/**

* 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];

/**

* Notifies about a new protocol message received from the session (as reported in

* `attachedToTarget` event).

*/

'Target.receivedMessageFromTarget': [Protocol.Target.ReceivedMessageFromTargetEvent];

/**

* Issued when a possible inspection target is created.

*/

'Target.targetCreated': [Protocol.Target.TargetCreatedEvent];

/**

* Issued when a target is destroyed.