chrome-devtools-frontend
Version:
Chrome DevTools UI
1,240 lines (1,237 loc) • 191 kB
TypeScript
// Copyright (c) 2020 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.
/**
* This file is auto-generated, do not edit manually. *
* Re-generate with: npm run generate-protocol-resources.
*/
/**
* Mappings from protocol event and command names to the types required for them.
*/
export namespace ProtocolMapping {
export interface Events {
/**
* The loadComplete event mirrors the load complete event sent by the browser to assistive
* technology when the web page has finished loading.
*/
'Accessibility.loadComplete': [Protocol.Accessibility.LoadCompleteEvent];
/**
* The nodesUpdated event is sent every time a previously requested node has changed the in tree.
*/
'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];
/**
* Fired when page is about to start a download.
*/
'Browser.downloadWillBegin': [Protocol.Browser.DownloadWillBeginEvent];
/**
* Fired when download makes progress. Last call has |done| == true.
*/
'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];
'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 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.
*/
'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.
*/
'DOM.inlineStyleInvalidated': [Protocol.DOM.InlineStyleInvalidatedEvent];
/**
* Called when a pseudo element is added to an element.
*/
'DOM.pseudoElementAdded': [Protocol.DOM.PseudoElementAddedEvent];
/**
* Called when top layer elements are changed.
*/
'DOM.topLayerElementsUpdated': [];
/**
* Fired when a node's scrollability state changes.
*/
'DOM.scrollableFlagUpdated': [Protocol.DOM.ScrollableFlagUpdatedEvent];
/**
* Called when a pseudo element is removed from an element.
*/
'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.
*/
'DOM.shadowRootPopped': [Protocol.DOM.ShadowRootPoppedEvent];
/**
* Called when shadow root is pushed into the element.
*/
'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];
/**
* Notification sent after the virtual time budget for the current VirtualTimePolicy has run out.
*/
'Emulation.virtualTimeBudgetExpired': [];
/**
* Emitted only when `Input.setInterceptDrags` is enabled. Use this data with `Input.dispatchDragEvent` to
* restore normal drag and drop behavior.
*/
'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': [];
'LayerTree.layerPainted': [Protocol.LayerTree.LayerPaintedEvent];
'LayerTree.layerTreeDidChange': [Protocol.LayerTree.LayerTreeDidChangeEvent];
/**
* Issued when new message was logged.
*/
'Log.entryAdded': [Protocol.Log.EntryAddedEvent];
/**
* 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.
*/
'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
*/
'Network.resourceChangedPriority': [Protocol.Network.ResourceChangedPriorityEvent];
/**
* Fired when a signed exchange was received over the network
*/
'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.
*/
'Network.directTCPSocketCreated': [Protocol.Network.DirectTCPSocketCreatedEvent];
/**
* Fired when direct_socket.TCPSocket connection is opened.
*/
'Network.directTCPSocketOpened': [Protocol.Network.DirectTCPSocketOpenedEvent];
/**
* Fired when direct_socket.TCPSocket is aborted.
*/
'Network.directTCPSocketAborted': [Protocol.Network.DirectTCPSocketAbortedEvent];
/**
* Fired when direct_socket.TCPSocket is closed.
*/
'Network.directTCPSocketClosed': [Protocol.Network.DirectTCPSocketClosedEvent];
/**
* Fired when data is sent to tcp direct socket stream.
*/
'Network.directTCPSocketChunkSent': [Protocol.Network.DirectTCPSocketChunkSentEvent];
/**
* Fired when data is received from tcp direct socket stream.
*/
'Network.directTCPSocketChunkReceived': [Protocol.Network.DirectTCPSocketChunkReceivedEvent];
/**
* Fired upon direct_socket.UDPSocket creation.
*/
'Network.directUDPSocketCreated': [Protocol.Network.DirectUDPSocketCreatedEvent];
/**
* Fired when direct_socket.UDPSocket connection is opened.
*/
'Network.directUDPSocketOpened': [Protocol.Network.DirectUDPSocketOpenedEvent];
/**
* Fired when direct_socket.UDPSocket is aborted.
*/
'Network.directUDPSocketAborted': [Protocol.Network.DirectUDPSocketAbortedEvent];
/**
* Fired when direct_socket.UDPSocket is closed.
*/
'Network.directUDPSocketClosed': [Protocol.Network.DirectUDPSocketClosedEvent];
/**
* Fired when message is sent to udp direct socket stream.
*/
'Network.directUDPSocketChunkSent': [Protocol.Network.DirectUDPSocketChunkSentEvent];
/**
* Fired when message is received from udp direct socket stream.
*/
'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.
*/
'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.
*/
'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.
*/
'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.
*/
'Network.trustTokenOperationDone': [Protocol.Network.TrustTokenOperationDoneEvent];
/**
* Fired once security policy has been updated.
*/
'Network.policyUpdated': [];
/**
* Fired once when parsing the .wbn file has succeeded.
* The event contains the information about the web bundle contents.
*/
'Network.subresourceWebBundleMetadataReceived': [Protocol.Network.SubresourceWebBundleMetadataReceivedEvent];
/**
* Fired once when parsing the .wbn file has failed.
*/
'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.
*/
'Network.subresourceWebBundleInnerResponseParsed': [Protocol.Network.SubresourceWebBundleInnerResponseParsedEvent];
/**
* Fired when request for resources within a .wbn file failed.
*/
'Network.subresourceWebBundleInnerResponseError': [Protocol.Network.SubresourceWebBundleInnerResponseErrorEvent];
/**
* Is sent whenever a new report is added.
* And after 'enableReportingApi' for all existing reports.
*/
'Network.reportingApiReportAdded': [Protocol.Network.ReportingApiReportAddedEvent];
'Network.reportingApiReportUpdated': [Protocol.Network.ReportingApiReportUpdatedEvent];
'Network.reportingApiEndpointsChangedForOrigin': [Protocol.Network.ReportingApiEndpointsChangedForOriginEvent];
/**
* 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 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.
*/
'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.
*/
'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.
*/
'Page.documentOpened': [Protocol.Page.DocumentOpenedEvent];
'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).
*/
'Page.frameStartedNavigating': [Protocol.Page.FrameStartedNavigatingEvent];
/**
* Fired when a renderer-initiated navigation is requested.
* Navigation may still be cancelled after the event is issued.
*/
'Page.frameRequestedNavigation': [Protocol.Page.FrameRequestedNavigationEvent];
/**
* Fired when frame schedules a potential navigation.
*/
'Page.frameScheduledNavigation': [Protocol.Page.FrameScheduledNavigationEvent];
/**
* Fired when frame has started loading.
*/
'Page.frameStartedLoading': [Protocol.Page.FrameStartedLoadingEvent];
/**
* Fired when frame has stopped loading.
*/
'Page.frameStoppedLoading': [Protocol.Page.FrameStoppedLoadingEvent];
/**
* Fired when page is about to start a download.
* Deprecated. Use Browser.downloadWillBegin instead.
*/
'Page.downloadWillBegin': [Protocol.Page.DownloadWillBeginEvent];
/**
* Fired when download makes progress. Last call has |done| == true.
* Deprecated. Use Browser.downloadProgress instead.
*/
'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.
*/
'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.
*/
'Page.navigatedWithinDocument': [Protocol.Page.NavigatedWithinDocumentEvent];
/**
* Compressed image data requested by the `startScreencast`.
*/
'Page.screencastFrame': [Protocol.Page.ScreencastFrameEvent];
/**
* Fired when the page with currently enabled screencast was shown or hidden `.
*/
'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. Is only available
* if Page.setGenerateCompilationCache is enabled.
*/
'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];
/**
* 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.
*/
'Security.certificateError': [Protocol.Security.CertificateErrorEvent];
/**
* The security state of the page changed.
*/
'Security.visibleSecurityStateChanged': [Protocol.Security.VisibleSecurityStateChangedEvent];
/**
* The security state of the page changed. No longer being sent.
*/
'Security.securityStateChanged': [Protocol.Security.SecurityStateChangedEvent];
'ServiceWorker.workerErrorReported': [Protocol.ServiceWorker.WorkerErrorReportedEvent];
'ServiceWorker.workerRegistrationUpdated': [Protocol.ServiceWorker.WorkerRegistrationUpdatedEvent];
'ServiceWorker.workerVersionUpdated': [Protocol.ServiceWorker.WorkerVersionUpdatedEvent];
/**
* 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];
'Storage.attributionReportingSourceRegistered': [Protocol.Storage.AttributionReportingSourceRegisteredEvent];
'Storage.attributionReportingTriggerRegistered': [Protocol.Storage.AttributionReportingTriggerRegisteredEvent];
'Storage.attributionReportingReportSent': [Protocol.Storage.AttributionReportingReportSentEvent];
/**
* Issued when attached to target because of auto-attach or `attachToTarget` command.
*/
'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.
*/
'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.
*/
'Target.targetDestroyed': [Protocol.Target.TargetDestroyedEvent];
/**
* Issued when a target has crashed.
*/
'Target.targetCrashed': [Protocol.Target.TargetCrashedEvent];
/**
* Issued when some information about a target has changed. This only happens between
* `targetCreated` and `targetDestroyed`.
*/
'Target.targetInfoChanged': [Protocol.Target.TargetInfoChangedEvent];
/**
* Informs that port was successfully bound and got a specified connection id.
*/
'Tethering.accepted': [Protocol.Tethering.AcceptedEvent];
'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.
*/
'Tracing.dataCollected': [Protocol.Tracing.DataCollectedEvent];
/**
* Signals that tracing is stopped and there is no trace buffers pending flush, all data were
* 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.
*/
'WebAudio.contextCreated': [Protocol.WebAudio.ContextCreatedEvent];
/**
* Notifies that an existing BaseAudioContext will be destroyed.
*/
'WebAudio.contextWillBeDestroyed': [Protocol.WebAudio.ContextWillBeDestroyedEvent];
/**
* Notifies that existing BaseAudioContext has changed some properties (id stays the same)..
*/
'WebAudio.contextChanged': [Protocol.WebAudio.ContextChangedEvent];
/**
* Notifies that the construction of an AudioListener has finished.
*/
'WebAudio.audioListenerCreated': [Protocol.WebAudio.AudioListenerCreatedEvent];
/**
* Notifies that a new AudioListener has been created.
*/
'WebAudio.audioListenerWillBeDestroyed': [Protocol.WebAudio.AudioListenerWillBeDestroyedEvent];
/**
* Notifies that a new AudioNode has been created.
*/
'WebAudio.audioNodeCreated': [Protocol.WebAudio.AudioNodeCreatedEvent];
/**
* Notifies that an existing AudioNode has been destroyed.
*/
'WebAudio.audioNodeWillBeDestroyed': [Protocol.WebAudio.AudioNodeWillBeDestroyedEvent];
/**
* Notifies that a new AudioParam has been created.
*/
'WebAudio.audioParamCreated': [Protocol.WebAudio.AudioParamCreatedEvent];
/**
* Notifies that an existing AudioParam has been destroyed.
*/
'WebAudio.audioParamWillBeDestroyed': [Protocol.WebAudio.AudioParamWillBeDestroyedEvent];
/**
* Notifies that two AudioNodes are connected.
*/
'WebAudio.nodesConnected': [Protocol.WebAudio.NodesConnectedEvent];
/**
* Notifies that AudioNodes are disconnected. The destination can be null, and it means all the outgoing connections from the source are disconnected.
*/
'WebAudio.nodesDisconnected': [Protocol.WebAudio.NodesDisconnectedEvent];
/**
* Notifies that an AudioNode is connected to an AudioParam.
*/
'WebAudio.nodeParamConnected': [Protocol.WebAudio.NodeParamConnectedEvent];
/**
* Notifies that an AudioNode is disconnected to an AudioParam.
*/
'WebAudio.nodeParamDisconnected': [Protocol.WebAudio.NodeParamDisconnectedEvent];
/**
* Triggered when a credential is added to an authenticator.
*/
'WebAuthn.credentialAdded': [Protocol.WebAuthn.CredentialAddedEvent];
/**
* Triggered when a credential is deleted, e.g. through
* PublicKeyCredential.signalUnknownCredential().
*/
'WebAuthn.credentialDeleted': [Protocol.WebAuthn.CredentialDeletedEvent];
/**
* Triggered when a credential is updated, e.g. through
* PublicKeyCredential.signalCurrentUserDetails().
*/
'WebAuthn.credentialUpdated': [Protocol.WebAuthn.CredentialUpdatedEvent];
/**
* 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];
/**
* Fired when breakpoint is resolved to an actual script and location.
* Deprecated in favor of `resolvedBreakpoints` in the `scriptParsed` event.
*/
'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.
*/
'Profiler.preciseCoverageDeltaUpdate': [Protocol.Profiler.PreciseCoverageDeltaUpdateEvent];
/**
* Notification is issued every time when binding is called.
*/
'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];
}
export interface Commands {
/**
* Disables the accessibility domain.
*/
'Accessibility.disable': {
paramsType: [];
returnType: void;
};
/**
* Enables the accessibility domain which causes `AXNodeId`s to remain consistent between method calls.
* This turns on accessibility for the page, which can impact performance until accessibility is disabled.
*/
'Accessibility.enable': {
paramsType: [];
returnType: void;
};
/**
* Fetches the accessibility node and partial accessibility tree for this DOM node, if it exists.
*/
'Accessibility.getPartialAXTree': {
paramsType: [Protocol.Accessibility.GetPartialAXTreeRequest?];
returnType: Protocol.Accessibility.GetPartialAXTreeResponse;
};
/**
* Fetches the entire accessibility tree for the root Document
*/
'Accessibility.getFullAXTree': {
paramsType: [Protocol.Accessibility.GetFullAXTreeRequest?];
returnType: Protocol.Accessibility.GetFullAXTreeResponse;
};
/**
* Fetches the root node.
* Requires `enable()` to have been called previously.
*/
'Accessibility.getRootAXNode': {
paramsType: [Protocol.Accessibility.GetRootAXNodeRequest?];
returnType: Protocol.Accessibility.GetRootAXNodeResponse;
};
/**
* Fetches a node and all ancestors up to and including the root.
* Requires `enable()` to have been called previously.
*/
'Accessibility.getAXNodeAndAncestors': {
paramsType: [Protocol.Accessibility.GetAXNodeAndAncestorsRequest?];
returnType: Protocol.Accessibility.GetAXNodeAndAncestorsResponse;
};
/**
* Fetches a particular accessibility node by AXNodeId.
* Requires `enable()` to have been called previously.
*/
'Accessibility.getChildAXNodes': {
paramsType: [Protocol.Accessibility.GetChildAXNodesRequest];
returnType: Protocol.Accessibility.GetChildAXNodesResponse;
};
/**
* Query a DOM node's accessibility subtree for accessible name and role.
* This command computes the name and role for all nodes in the subtree, including those that are
* 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.
*/
'Accessibility.queryAXTree': {
paramsType: [Protocol.Accessibility.QueryAXTreeRequest?];
returnType: Protocol.Accessibility.QueryAXTreeResponse;
};
/**
* Disables animation domain notifications.
*/
'Animation.disable': {
paramsType: [];
returnType: void;
};
/**
* Enables animation domain notifications.
*/
'Animation.enable': {
paramsType: [];
returnType: void;
};
/**
* Returns the current time of the an animation.
*/
'Animation.getCurrentTime': {
paramsType: [Protocol.Animation.GetCurrentTimeRequest];
returnType: Protocol.Animation.GetCurrentTimeResponse;
};
/**
* Gets the playback rate of the document timeline.
*/
'Animation.getPlaybackRate': {
paramsType: [];
returnType: Protocol.Animation.GetPlaybackRateResponse;
};
/**
* Releases a set of animations to no longer be manipulated.
*/
'Animation.releaseAnimations': {
paramsType: [Protocol.Animation.ReleaseAnimationsRequest];
returnType: void;
};
/**
* Gets the remote object of the Animation.
*/
'Animation.resolveAnimation': {
paramsType: [Protocol.Animation.ResolveAnimationRequest];
returnType: Protocol.Animation.ResolveAnimationResponse;
};
/**
* Seek a set of animations to a particular time within each animation.
*/
'Animation.seekAnimations': {
paramsType: [Protocol.Animation.SeekAnimationsRequest];
returnType: void;
};
/**
* Sets the paused state of a set of animations.
*/
'Animation.setPaused': {
paramsType: [Protocol.Animation.SetPausedRequest];
returnType: void;
};
/**
* Sets the playback rate of the document timeline.
*/
'Animation.setPlaybackRate': {
paramsType: [Protocol.Animation.SetPlaybackRateRequest];
returnType: void;
};
/**
* Sets the timing of an animation node.
*/
'Animation.setTiming': {
paramsType: [Protocol.Animation.SetTimingRequest];
returnType: void;
};
/**
* Returns the response body and size if it were re-encoded with the specified settings. Only
* applies to images.
*/
'Audits.getEncodedResponse': {
paramsType: [Protocol.Audits.GetEncodedResponseRequest];
returnType: Protocol.Audits.GetEncodedResponseResponse;
};
/**
* Disables issues domain, prevents further issues from being reported to the client.
*/
'Audits.disable': {
paramsType: [];
returnType: void;
};
/**
* Enables issues domain, sends the issues collected so far to the client by means of the
* `issueAdded` event.
*/
'Audits.enable': {
paramsType: [];
returnType: void;
};
/**
* Runs the contrast check for the target page. Found issues are reported
* using Audits.issueAdded event.
*/
'Audits.checkContrast': {
paramsType: [Protocol.Audits.CheckContrastRequest?];
returnType: void;
};
/**
* Runs the form issues check for the target page. Found issues are reported
* using Audits.issueAdded event.
*/
'Audits.checkFormsIssues': {
paramsType: [];
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.
*/
'Extensions.loadUnpacked': {
paramsType: [Protocol.Extensions.LoadUnpackedRequest];
returnType: Protocol.Extensions.LoadUnpackedResponse;
};
/**
* 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.
*/
'Extensions.uninstall': {
paramsType: [Protocol.Extensions.UninstallRequest];
returnType: void;
};
/**
* Gets data from extension storage in the given `storageArea`. If `keys` is
* specified, these are used to filter the result.
*/
'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;
};
/**
* Trigger autofill on a form identified by the fieldId.
* If the field and related form cannot be autofilled, returns an error.
*/
'Autofill.trigger': {
paramsType: [Protocol.Autofill.TriggerRequest];
returnType: void;
};
/**
* Set addresses so that developers can verify their forms implementation.
*/
'Autofill.setAddresses': {
paramsType: [Protocol.Autofill.SetAddressesRequest];
returnType: void;
};
/**
* Disables autofill domain notifications.
*/
'Autofill.disable': {
paramsType: [];
returnType: void;
};
/**
* Enables autofill domain notifications.
*/
'Autofill.enable': {
paramsType: [];
returnType: void;
};
/**
* Enables event updates for the service.
*/
'BackgroundService.startObserving': {
paramsType: [Protocol.BackgroundService.StartObservingRequest];
returnType: void;
};
/**
* Disables event updates for the service.
*/
'BackgroundService.stopObserving': {
paramsType: [Protocol.BackgroundService.StopObservingRequest];
returnType: void;
};
/**
* Set the recording state for the service.
*/
'BackgroundService.setRecording': {
paramsType: [Protocol.BackgroundService.SetRecordingRequest];
returnType: void;
};
/**
* Clears all stored data for the service.
*/
'BackgroundService.clearEvents': {
paramsType: [Protocol.BackgroundService.ClearEventsRequest];
returnType: void;
};
/**
* Set permission settings for given origin.
*/
'Browser.setPermission': {
paramsType: [Protocol.Browser.SetPermissionRequest];
returnType: void;
};
/**
* Grant specific permissions to the given origin and reject all others.
*/
'Browser.grantPermissions': {
paramsType: [Protocol.Browser.GrantPermissionsRequest];
returnType: void;
};
/**
* Reset all permission management for all origins.
*/
'Browser.resetPermissions': {
paramsType: [Protocol.Browser.ResetPermissionsRequest?];
returnType: void;
};
/**
* Set the behavior when downloading a file.
*/
'Browser.setDownloadBehavior': {
paramsType: [Protocol.Browser.SetDownloadBehaviorRequest];
returnType: void;
};
/**
* Cancel a download if in progress
*/
'Browser.cancelDownload': {
paramsType: [Protocol.Browser.CancelDownloadRequest];
returnType: void;
};
/**
* Close browser gracefully.
*/
'Browser.close': {
paramsType: [];
returnType: void;
};
/**
* Crashes browser on the main thread.
*/
'Browser.crash': {
paramsType: [];
returnType: void;
};
/**
* Crashes GPU process.
*/
'Browser.crashGpuProcess': {
paramsType: [];
returnType: void;
};
/**
* Returns version information.
*/
'Browser.getVersion': {
paramsType: [];
returnType: Protocol.Browser.GetVersionResponse;
};
/**
* Returns the command line switches for the browser process if, and only if
* --enable-automation is on the commandline.
*/
'Browser.getBrowserCommandLine': {
paramsType: [];
returnType: Protocol.Browser.GetBrowserCommandLineResponse;
};
/**
* Get Chrome histograms.
*/
'Browser.getHistograms': {
paramsType: [Protocol.Browser.GetHistogramsRequest?];
returnType: Protocol.Browser.GetHistogramsResponse;
};
/**
* Get a Chrome histogram by name.
*/
'Browser.get