// 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' /** * API generated from Protocol commands and events. */ export namespace ProtocolProxyApi { export interface ProtocolApi { Console: ConsoleApi; Debugger: DebuggerApi; HeapProfiler: HeapProfilerApi; Profiler: ProfilerApi; Runtime: RuntimeApi; Schema: SchemaApi; Accessibility: AccessibilityApi; Animation: AnimationApi; Audits: AuditsApi; Autofill: AutofillApi; BackgroundService: BackgroundServiceApi; BluetoothEmulation: BluetoothEmulationApi; Browser: BrowserApi; CSS: CSSApi; CacheStorage: CacheStorageApi; Cast: CastApi; DOM: DOMApi; DOMDebugger: DOMDebuggerApi; DOMSnapshot: DOMSnapshotApi; DOMStorage: DOMStorageApi; DeviceAccess: DeviceAccessApi; DeviceOrientation: DeviceOrientationApi; Emulation: EmulationApi; EventBreakpoints: EventBreakpointsApi; Extensions: ExtensionsApi; FedCm: FedCmApi; Fetch: FetchApi; FileSystem: FileSystemApi; HeadlessExperimental: HeadlessExperimentalApi; IO: IOApi; IndexedDB: IndexedDBApi; Input: InputApi; Inspector: InspectorApi; LayerTree: LayerTreeApi; Log: LogApi; Media: MediaApi; Memory: MemoryApi; Network: NetworkApi; Overlay: OverlayApi; PWA: PWAApi; Page: PageApi; Performance: PerformanceApi; PerformanceTimeline: PerformanceTimelineApi; Preload: PreloadApi; Security: SecurityApi; ServiceWorker: ServiceWorkerApi; SmartCardEmulation: SmartCardEmulationApi; Storage: StorageApi; SystemInfo: SystemInfoApi; Target: TargetApi; Tethering: TetheringApi; Tracing: TracingApi; WebAudio: WebAudioApi; WebAuthn: WebAuthnApi; } export interface ConsoleApi { /** * Does nothing. */ clearMessages(): Promise; /** * Disables console domain, prevents further console messages from being reported to the client. */ disable(): Promise; /** * Enables console domain, sends the messages collected so far to the client by means of the * `messageAdded` notification. */ enable(): Promise; /** * Issued when new console message is added. */ on(event: 'messageAdded', listener: (params: Protocol.Console.MessageAddedEvent) => void): void; } export interface DebuggerApi { /** * Continues execution until specific location is reached. */ continueToLocation(params: Protocol.Debugger.ContinueToLocationRequest): Promise; /** * Disables debugger for given page. */ disable(): Promise; /** * Enables debugger for the given page. Clients should not assume that the debugging has been * enabled until the result for this command is received. */ enable(params: Protocol.Debugger.EnableRequest): Promise; /** * Evaluates expression on a given call frame. */ evaluateOnCallFrame(params: Protocol.Debugger.EvaluateOnCallFrameRequest): Promise; /** * Returns possible locations for breakpoint. scriptId in start and end range locations should be * the same. */ getPossibleBreakpoints(params: Protocol.Debugger.GetPossibleBreakpointsRequest): Promise; /** * Returns source for the script with given id. */ getScriptSource(params: Protocol.Debugger.GetScriptSourceRequest): Promise; /** * @experimental */ disassembleWasmModule(params: Protocol.Debugger.DisassembleWasmModuleRequest): Promise; /** * Disassemble the next chunk of lines for the module corresponding to the * 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 */ nextWasmDisassemblyChunk(params: Protocol.Debugger.NextWasmDisassemblyChunkRequest): Promise; /** * This command is deprecated. Use getScriptSource instead. * @deprecated */ getWasmBytecode(params: Protocol.Debugger.GetWasmBytecodeRequest): Promise; /** * Returns stack trace with given `stackTraceId`. * @experimental */ getStackTrace(params: Protocol.Debugger.GetStackTraceRequest): Promise; /** * Stops on the next JavaScript statement. */ pause(): Promise; /** * @deprecated * @experimental */ pauseOnAsyncCall(params: Protocol.Debugger.PauseOnAsyncCallRequest): Promise; /** * Removes JavaScript breakpoint. */ removeBreakpoint(params: Protocol.Debugger.RemoveBreakpointRequest): Promise; /** * Restarts particular call frame from the beginning. The old, deprecated * behavior of `restartFrame` is to stay paused and allow further CDP commands * after a restart was scheduled. This can cause problems with restarting, so * we now continue execution immediatly after it has been scheduled until we * reach the beginning of the restarted frame. * * To stay back-wards compatible, `restartFrame` now expects a `mode` * parameter to be present. If the `mode` parameter is missing, `restartFrame` * errors out. * * The various return values are deprecated and `callFrames` is always empty. * Use the call frames from the `Debugger#paused` events instead, that fires * once V8 pauses at the beginning of the restarted function. */ restartFrame(params: Protocol.Debugger.RestartFrameRequest): Promise; /** * Resumes JavaScript execution. */ resume(params: Protocol.Debugger.ResumeRequest): Promise; /** * Searches for given string in script content. */ searchInContent(params: Protocol.Debugger.SearchInContentRequest): Promise; /** * Enables or disables async call stacks tracking. */ setAsyncCallStackDepth(params: Protocol.Debugger.SetAsyncCallStackDepthRequest): Promise; /** * 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 */ setBlackboxExecutionContexts(params: Protocol.Debugger.SetBlackboxExecutionContextsRequest): Promise; /** * 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 */ setBlackboxPatterns(params: Protocol.Debugger.SetBlackboxPatternsRequest): Promise; /** * Makes backend skip steps in the script in blackboxed ranges. VM will try leave blacklisted * 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 */ setBlackboxedRanges(params: Protocol.Debugger.SetBlackboxedRangesRequest): Promise; /** * Sets JavaScript breakpoint at a given location. */ setBreakpoint(params: Protocol.Debugger.SetBreakpointRequest): Promise; /** * Sets instrumentation breakpoint. */ setInstrumentationBreakpoint(params: Protocol.Debugger.SetInstrumentationBreakpointRequest): Promise; /** * Sets JavaScript breakpoint at given location specified either by URL or URL regex. Once this * command is issued, all existing parsed scripts will have breakpoints resolved and returned in * `locations` property. Further matching script parsing will result in subsequent * `breakpointResolved` events issued. This logical breakpoint will survive page reloads. */ setBreakpointByUrl(params: Protocol.Debugger.SetBreakpointByUrlRequest): Promise; /** * 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 */ setBreakpointOnFunctionCall(params: Protocol.Debugger.SetBreakpointOnFunctionCallRequest): Promise; /** * Activates / deactivates all breakpoints on the page. */ setBreakpointsActive(params: Protocol.Debugger.SetBreakpointsActiveRequest): Promise; /** * Defines pause on exceptions state. Can be set to stop on all exceptions, uncaught exceptions, * or caught exceptions, no exceptions. Initial pause on exceptions state is `none`. */ setPauseOnExceptions(params: Protocol.Debugger.SetPauseOnExceptionsRequest): Promise; /** * Changes return value in top frame. Available only at return break position. * @experimental */ setReturnValue(params: Protocol.Debugger.SetReturnValueRequest): Promise; /** * Edits JavaScript source live. * * In general, functions that are currently on the stack can not be edited with * a single exception: If the edited function is the top-most stack frame and * that is the only activation of that function on the stack. In this case * the live edit will be successful and a `Debugger.restartFrame` for the * top-most function is automatically triggered. */ setScriptSource(params: Protocol.Debugger.SetScriptSourceRequest): Promise; /** * Makes page not interrupt on any pauses (breakpoint, exception, dom exception etc). */ setSkipAllPauses(params: Protocol.Debugger.SetSkipAllPausesRequest): Promise; /** * Changes value of variable in a callframe. Object-based scopes are not supported and must be * mutated manually. */ setVariableValue(params: Protocol.Debugger.SetVariableValueRequest): Promise; /** * Steps into the function call. */ stepInto(params: Protocol.Debugger.StepIntoRequest): Promise; /** * Steps out of the function call. */ stepOut(): Promise; /** * Steps over the statement. */ stepOver(params: Protocol.Debugger.StepOverRequest): Promise; /** * Fired when breakpoint is resolved to an actual script and location. * Deprecated in favor of `resolvedBreakpoints` in the `scriptParsed` event. * @deprecated */ on(event: 'breakpointResolved', listener: (params: Protocol.Debugger.BreakpointResolvedEvent) => void): void; /** * Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria. */ on(event: 'paused', listener: (params: Protocol.Debugger.PausedEvent) => void): void; /** * Fired when the virtual machine resumed execution. */ on(event: 'resumed', listener: () => void): void; /** * Fired when virtual machine fails to parse the script. */ on(event: 'scriptFailedToParse', listener: (params: Protocol.Debugger.ScriptFailedToParseEvent) => void): void; /** * Fired when virtual machine parses script. This event is also fired for all known and uncollected * scripts upon enabling debugger. */ on(event: 'scriptParsed', listener: (params: Protocol.Debugger.ScriptParsedEvent) => void): void; } export interface HeapProfilerApi { /** * Enables console to refer to the node with given id via $x (see Command Line API for more details * $x functions). */ addInspectedHeapObject(params: Protocol.HeapProfiler.AddInspectedHeapObjectRequest): Promise; collectGarbage(): Promise; disable(): Promise; enable(): Promise; getHeapObjectId(params: Protocol.HeapProfiler.GetHeapObjectIdRequest): Promise; getObjectByHeapObjectId(params: Protocol.HeapProfiler.GetObjectByHeapObjectIdRequest): Promise; getSamplingProfile(): Promise; startSampling(params: Protocol.HeapProfiler.StartSamplingRequest): Promise; startTrackingHeapObjects(params: Protocol.HeapProfiler.StartTrackingHeapObjectsRequest): Promise; stopSampling(): Promise; stopTrackingHeapObjects(params: Protocol.HeapProfiler.StopTrackingHeapObjectsRequest): Promise; takeHeapSnapshot(params: Protocol.HeapProfiler.TakeHeapSnapshotRequest): Promise; on(event: 'addHeapSnapshotChunk', listener: (params: Protocol.HeapProfiler.AddHeapSnapshotChunkEvent) => void): void; /** * If heap objects tracking has been started then backend may send update for one or more fragments */ on(event: 'heapStatsUpdate', listener: (params: Protocol.HeapProfiler.HeapStatsUpdateEvent) => void): void; /** * 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. */ on(event: 'lastSeenObjectId', listener: (params: Protocol.HeapProfiler.LastSeenObjectIdEvent) => void): void; on(event: 'reportHeapSnapshotProgress', listener: (params: Protocol.HeapProfiler.ReportHeapSnapshotProgressEvent) => void): void; on(event: 'resetProfiles', listener: () => void): void; } export interface ProfilerApi { disable(): Promise; enable(): Promise; /** * Collect coverage data for the current isolate. The coverage data may be incomplete due to * garbage collection. */ getBestEffortCoverage(): Promise; /** * Changes CPU profiler sampling interval. Must be called before CPU profiles recording started. */ setSamplingInterval(params: Protocol.Profiler.SetSamplingIntervalRequest): Promise; start(): Promise; /** * Enable precise code coverage. Coverage data for JavaScript executed before enabling precise code * coverage may be incomplete. Enabling prevents running optimized code and resets execution * counters. */ startPreciseCoverage(params: Protocol.Profiler.StartPreciseCoverageRequest): Promise; stop(): Promise; /** * Disable precise code coverage. Disabling releases unnecessary execution count records and allows * executing optimized code. */ stopPreciseCoverage(): Promise; /** * Collect coverage data for the current isolate, and resets execution counters. Precise code * coverage needs to have started. */ takePreciseCoverage(): Promise; on(event: 'consoleProfileFinished', listener: (params: Protocol.Profiler.ConsoleProfileFinishedEvent) => void): void; /** * Sent when new profile recording is started using console.profile() call. */ on(event: 'consoleProfileStarted', listener: (params: Protocol.Profiler.ConsoleProfileStartedEvent) => void): void; /** * 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 */ on(event: 'preciseCoverageDeltaUpdate', listener: (params: Protocol.Profiler.PreciseCoverageDeltaUpdateEvent) => void): void; } export interface RuntimeApi { /** * Add handler to promise with given promise object id. */ awaitPromise(params: Protocol.Runtime.AwaitPromiseRequest): Promise; /** * Calls function with given declaration on the given object. Object group of the result is * inherited from the target object. */ callFunctionOn(params: Protocol.Runtime.CallFunctionOnRequest): Promise; /** * Compiles expression. */ compileScript(params: Protocol.Runtime.CompileScriptRequest): Promise; /** * Disables reporting of execution contexts creation. */ disable(): Promise; /** * Discards collected exceptions and console API calls. */ discardConsoleEntries(): Promise; /** * Enables reporting of execution contexts creation by means of `executionContextCreated` event. * When the reporting gets enabled the event will be sent immediately for each existing execution * context. */ enable(): Promise; /** * Evaluates expression on global object. */ evaluate(params: Protocol.Runtime.EvaluateRequest): Promise; /** * Returns the isolate id. * @experimental */ getIsolateId(): Promise; /** * Returns the JavaScript heap usage. * It is the total usage of the corresponding isolate not scoped to a particular Runtime. * @experimental */ getHeapUsage(): Promise; /** * Returns properties of a given object. Object group of the result is inherited from the target * object. */ getProperties(params: Protocol.Runtime.GetPropertiesRequest): Promise; /** * Returns all let, const and class variables from global scope. */ globalLexicalScopeNames(params: Protocol.Runtime.GlobalLexicalScopeNamesRequest): Promise; queryObjects(params: Protocol.Runtime.QueryObjectsRequest): Promise; /** * Releases remote object with given id. */ releaseObject(params: Protocol.Runtime.ReleaseObjectRequest): Promise; /** * Releases all remote objects that belong to a given group. */ releaseObjectGroup(params: Protocol.Runtime.ReleaseObjectGroupRequest): Promise; /** * Tells inspected instance to run if it was waiting for debugger to attach. */ runIfWaitingForDebugger(): Promise; /** * Runs script with given id in a given context. */ runScript(params: Protocol.Runtime.RunScriptRequest): Promise; /** * Enables or disables async call stacks tracking. */ setAsyncCallStackDepth(params: Protocol.Runtime.SetAsyncCallStackDepthRequest): Promise; /** * @experimental */ setCustomObjectFormatterEnabled(params: Protocol.Runtime.SetCustomObjectFormatterEnabledRequest): Promise; /** * @experimental */ setMaxCallStackSizeToCapture(params: Protocol.Runtime.SetMaxCallStackSizeToCaptureRequest): Promise; /** * Terminate current or next JavaScript execution. * Will cancel the termination when the outer-most script execution ends. * @experimental */ terminateExecution(): Promise; /** * If executionContextId is empty, adds binding with the given name on the * global objects of all inspected contexts, including those created later, * bindings survive reloads. * Binding function takes exactly one argument, this argument should be string, * in case of any other input, function throws an exception. * Each binding function call produces Runtime.bindingCalled notification. */ addBinding(params: Protocol.Runtime.AddBindingRequest): Promise; /** * This method does not remove binding function from global object but * unsubscribes current runtime agent from Runtime.bindingCalled notifications. */ removeBinding(params: Protocol.Runtime.RemoveBindingRequest): Promise; /** * This method tries to lookup and populate exception details for a * JavaScript Error object. * 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 */ getExceptionDetails(params: Protocol.Runtime.GetExceptionDetailsRequest): Promise; /** * Notification is issued every time when binding is called. * @experimental */ on(event: 'bindingCalled', listener: (params: Protocol.Runtime.BindingCalledEvent) => void): void; /** * Issued when console API was called. */ on(event: 'consoleAPICalled', listener: (params: Protocol.Runtime.ConsoleAPICalledEvent) => void): void; /** * Issued when unhandled exception was revoked. */ on(event: 'exceptionRevoked', listener: (params: Protocol.Runtime.ExceptionRevokedEvent) => void): void; /** * Issued when exception was thrown and unhandled. */ on(event: 'exceptionThrown', listener: (params: Protocol.Runtime.ExceptionThrownEvent) => void): void; /** * Issued when new execution context is created. */ on(event: 'executionContextCreated', listener: (params: Protocol.Runtime.ExecutionContextCreatedEvent) => void): void; /** * Issued when execution context is destroyed. */ on(event: 'executionContextDestroyed', listener: (params: Protocol.Runtime.ExecutionContextDestroyedEvent) => void): void; /** * Issued when all executionContexts were cleared in browser */ on(event: 'executionContextsCleared', listener: () => void): void; /** * Issued when object should be inspected (for example, as a result of inspect() command line API * call). */ on(event: 'inspectRequested', listener: (params: Protocol.Runtime.InspectRequestedEvent) => void): void; } export interface SchemaApi { /** * Returns supported domains. */ getDomains(): Promise; } export interface AccessibilityApi { /** * Disables the accessibility domain. */ disable(): Promise; /** * 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. */ enable(): Promise; /** * Fetches the accessibility node and partial accessibility tree for this DOM node, if it exists. * @experimental */ getPartialAXTree(params: Protocol.Accessibility.GetPartialAXTreeRequest): Promise; /** * Fetches the entire accessibility tree for the root Document * @experimental */ getFullAXTree(params: Protocol.Accessibility.GetFullAXTreeRequest): Promise; /** * Fetches the root node. * Requires `enable()` to have been called previously. * @experimental */ getRootAXNode(params: Protocol.Accessibility.GetRootAXNodeRequest): Promise; /** * Fetches a node and all ancestors up to and including the root. * Requires `enable()` to have been called previously. * @experimental */ getAXNodeAndAncestors(params: Protocol.Accessibility.GetAXNodeAndAncestorsRequest): Promise; /** * Fetches a particular accessibility node by AXNodeId. * Requires `enable()` to have been called previously. * @experimental */ getChildAXNodes(params: Protocol.Accessibility.GetChildAXNodesRequest): Promise; /** * 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. * @experimental */ queryAXTree(params: Protocol.Accessibility.QueryAXTreeRequest): Promise; /** * The loadComplete event mirrors the load complete event sent by the browser to assistive * technology when the web page has finished loading. * @experimental */ on(event: 'loadComplete', listener: (params: Protocol.Accessibility.LoadCompleteEvent) => void): void; /** * The nodesUpdated event is sent every time a previously requested node has changed the in tree. * @experimental */ on(event: 'nodesUpdated', listener: (params: Protocol.Accessibility.NodesUpdatedEvent) => void): void; } export interface AnimationApi { /** * Disables animation domain notifications. */ disable(): Promise; /** * Enables animation domain notifications. */ enable(): Promise; /** * Returns the current time of the an animation. */ getCurrentTime(params: Protocol.Animation.GetCurrentTimeRequest): Promise; /** * Gets the playback rate of the document timeline. */ getPlaybackRate(): Promise; /** * Releases a set of animations to no longer be manipulated. */ releaseAnimations(params: Protocol.Animation.ReleaseAnimationsRequest): Promise; /** * Gets the remote object of the Animation. */ resolveAnimation(params: Protocol.Animation.ResolveAnimationRequest): Promise; /** * Seek a set of animations to a particular time within each animation. */ seekAnimations(params: Protocol.Animation.SeekAnimationsRequest): Promise; /** * Sets the paused state of a set of animations. */ setPaused(params: Protocol.Animation.SetPausedRequest): Promise; /** * Sets the playback rate of the document timeline. */ setPlaybackRate(params: Protocol.Animation.SetPlaybackRateRequest): Promise; /** * Sets the timing of an animation node. */ setTiming(params: Protocol.Animation.SetTimingRequest): Promise; /** * Event for when an animation has been cancelled. */ on(event: 'animationCanceled', listener: (params: Protocol.Animation.AnimationCanceledEvent) => void): void; /** * Event for each animation that has been created. */ on(event: 'animationCreated', listener: (params: Protocol.Animation.AnimationCreatedEvent) => void): void; /** * Event for animation that has been started. */ on(event: 'animationStarted', listener: (params: Protocol.Animation.AnimationStartedEvent) => void): void; /** * Event for animation that has been updated. */ on(event: 'animationUpdated', listener: (params: Protocol.Animation.AnimationUpdatedEvent) => void): void; } export interface AuditsApi { /** * Returns the response body and size if it were re-encoded with the specified settings. Only * applies to images. */ getEncodedResponse(params: Protocol.Audits.GetEncodedResponseRequest): Promise; /** * Disables issues domain, prevents further issues from being reported to the client. */ disable(): Promise; /** * Enables issues domain, sends the issues collected so far to the client by means of the * `issueAdded` event. */ enable(): Promise; /** * Runs the form issues check for the target page. Found issues are reported * using Audits.issueAdded event. */ checkFormsIssues(): Promise; on(event: 'issueAdded', listener: (params: Protocol.Audits.IssueAddedEvent) => void): void; } export interface AutofillApi { /** * Trigger autofill on a form identified by the fieldId. * If the field and related form cannot be autofilled, returns an error. */ trigger(params: Protocol.Autofill.TriggerRequest): Promise; /** * Set addresses so that developers can verify their forms implementation. */ setAddresses(params: Protocol.Autofill.SetAddressesRequest): Promise; /** * Disables autofill domain notifications. */ disable(): Promise; /** * Enables autofill domain notifications. */ enable(): Promise; /** * Emitted when an address form is filled. */ on(event: 'addressFormFilled', listener: (params: Protocol.Autofill.AddressFormFilledEvent) => void): void; } export interface BackgroundServiceApi { /** * Enables event updates for the service. */ startObserving(params: Protocol.BackgroundService.StartObservingRequest): Promise; /** * Disables event updates for the service. */ stopObserving(params: Protocol.BackgroundService.StopObservingRequest): Promise; /** * Set the recording state for the service. */ setRecording(params: Protocol.BackgroundService.SetRecordingRequest): Promise; /** * Clears all stored data for the service. */ clearEvents(params: Protocol.BackgroundService.ClearEventsRequest): Promise; /** * Called when the recording state for the service has been updated. */ on(event: 'recordingStateChanged', listener: (params: Protocol.BackgroundService.RecordingStateChangedEvent) => void): void; /** * Called with all existing backgroundServiceEvents when enabled, and all new * events afterwards if enabled and recording. */ on(event: 'backgroundServiceEventReceived', listener: (params: Protocol.BackgroundService.BackgroundServiceEventReceivedEvent) => void): void; } export interface BluetoothEmulationApi { /** * Enable the BluetoothEmulation domain. */ enable(params: Protocol.BluetoothEmulation.EnableRequest): Promise; /** * Set the state of the simulated central. */ setSimulatedCentralState(params: Protocol.BluetoothEmulation.SetSimulatedCentralStateRequest): Promise; /** * Disable the BluetoothEmulation domain. */ disable(): Promise; /** * Simulates a peripheral with |address|, |name| and |knownServiceUuids| * that has already been connected to the system. */ simulatePreconnectedPeripheral(params: Protocol.BluetoothEmulation.SimulatePreconnectedPeripheralRequest): Promise; /** * Simulates an advertisement packet described in |entry| being received by * the central. */ simulateAdvertisement(params: Protocol.BluetoothEmulation.SimulateAdvertisementRequest): Promise; /** * Simulates the response code from the peripheral with |address| for a * GATT operation of |type|. The |code| value follows the HCI Error Codes from * Bluetooth Core Specification Vol 2 Part D 1.3 List Of Error Codes. */ simulateGATTOperationResponse(params: Protocol.BluetoothEmulation.SimulateGATTOperationResponseRequest): Promise; /** * Simulates the response from the characteristic with |characteristicId| for a * characteristic operation of |type|. The |code| value follows the Error * Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response. * The |data| is expected to exist when simulating a successful read operation * response. */ simulateCharacteristicOperationResponse(params: Protocol.BluetoothEmulation.SimulateCharacteristicOperationResponseRequest): Promise; /** * Simulates the response from the descriptor with |descriptorId| for a * descriptor operation of |type|. The |code| value follows the Error * Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response. * The |data| is expected to exist when simulating a successful read operation * response. */ simulateDescriptorOperationResponse(params: Protocol.BluetoothEmulation.SimulateDescriptorOperationResponseRequest): Promise; /** * Adds a service with |serviceUuid| to the peripheral with |address|. */ addService(params: Protocol.BluetoothEmulation.AddServiceRequest): Promise; /** * Removes the service respresented by |serviceId| from the simulated central. */ removeService(params: Protocol.BluetoothEmulation.RemoveServiceRequest): Promise; /** * Adds a characteristic with |characteristicUuid| and |properties| to the * service represented by |serviceId|. */ addCharacteristic(params: Protocol.BluetoothEmulation.AddCharacteristicRequest): Promise; /** * Removes the characteristic respresented by |characteristicId| from the * simulated central. */ removeCharacteristic(params: Protocol.BluetoothEmulation.RemoveCharacteristicRequest): Promise; /** * Adds a descriptor with |descriptorUuid| to the characteristic respresented * by |characteristicId|. */ addDescriptor(params: Protocol.BluetoothEmulation.AddDescriptorRequest): Promise; /** * Removes the descriptor with |descriptorId| from the simulated central. */ removeDescriptor(params: Protocol.BluetoothEmulation.RemoveDescriptorRequest): Promise; /** * Simulates a GATT disconnection from the peripheral with |address|. */ simulateGATTDisconnection(params: Protocol.BluetoothEmulation.SimulateGATTDisconnectionRequest): Promise; /** * Event for when a GATT operation of |type| to the peripheral with |address| * happened. */ on(event: 'gattOperationReceived', listener: (params: Protocol.BluetoothEmulation.GattOperationReceivedEvent) => void): void; /** * 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. */ on(event: 'characteristicOperationReceived', listener: (params: Protocol.BluetoothEmulation.CharacteristicOperationReceivedEvent) => void): void; /** * Event for when a descriptor operation of |type| to the descriptor * respresented by |descriptorId| happened. |data| is expected to exist when * |type| is write. */ on(event: 'descriptorOperationReceived', listener: (params: Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent) => void): void; } export interface BrowserApi { /** * Set permission settings for given embedding and embedded origins. * @experimental */ setPermission(params: Protocol.Browser.SetPermissionRequest): Promise; /** * Grant specific permissions to the given origin and reject all others. Deprecated. Use * setPermission instead. * @deprecated * @experimental */ grantPermissions(params: Protocol.Browser.GrantPermissionsRequest): Promise; /** * Reset all permission management for all origins. */ resetPermissions(params: Protocol.Browser.ResetPermissionsRequest): Promise; /** * Set the behavior when downloading a file. * @experimental */ setDownloadBehavior(params: Protocol.Browser.SetDownloadBehaviorRequest): Promise; /** * Cancel a download if in progress * @experimental */ cancelDownload(params: Protocol.Browser.CancelDownloadRequest): Promise; /** * Close browser gracefully. */ close(): Promise; /** * Crashes browser on the main thread. * @experimental */ crash(): Promise; /** * Crashes GPU process. * @experimental */ crashGpuProcess(): Promise; /** * Returns version information. */ getVersion(): Promise; /** * Returns the command line switches for the browser process if, and only if * --enable-automation is on the commandline. * @experimental */ getBrowserCommandLine(): Promise; /** * Get Chrome histograms. * @experimental */ getHistograms(params: Protocol.Browser.GetHistogramsRequest): Promise; /** * Get a Chrome histogram by name. * @experimental */ getHistogram(params: Protocol.Browser.GetHistogramRequest): Promise; /** * Get position and size of the browser window. * @experimental */ getWindowBounds(params: Protocol.Browser.GetWindowBoundsRequest): Promise; /** * Get the browser window that contains the devtools target. * @experimental */ getWindowForTarget(params: Protocol.Browser.GetWindowForTargetRequest): Promise; /** * Set position and/or size of the browser window. * @experimental */ setWindowBounds(params: Protocol.Browser.SetWindowBoundsRequest): Promise; /** * Set size of the browser contents resizing browser window as necessary. * @experimental */ setContentsSize(params: Protocol.Browser.SetContentsSizeRequest): Promise; /** * Set dock tile details, platform-specific. * @experimental */ setDockTile(params: Protocol.Browser.SetDockTileRequest): Promise; /** * Invoke custom browser commands used by telemetry. * @experimental */ executeBrowserCommand(params: Protocol.Browser.ExecuteBrowserCommandRequest): Promise; /** * Allows a site to use privacy sandbox features that require enrollment * without the site actually being enrolled. Only supported on page targets. */ addPrivacySandboxEnrollmentOverride(params: Protocol.Browser.AddPrivacySandboxEnrollmentOverrideRequest): Promise; /** * Configures encryption keys used with a given privacy sandbox API to talk * to a trusted coordinator. Since this is intended for test automation only, * coordinatorOrigin must be a .test domain. No existing coordinator * configuration for the origin may exist. */ addPrivacySandboxCoordinatorKeyConfig(params: Protocol.Browser.AddPrivacySandboxCoordinatorKeyConfigRequest): Promise; /** * Fired when page is about to start a download. * @experimental */ on(event: 'downloadWillBegin', listener: (params: Protocol.Browser.DownloadWillBeginEvent) => void): void; /** * Fired when download makes progress. Last call has |done| == true. * @experimental */ on(event: 'downloadProgress', listener: (params: Protocol.Browser.DownloadProgressEvent) => void): void; } export interface CSSApi { /** * Inserts a new rule with the given `ruleText` in a stylesheet with given `styleSheetId`, at the * position specified by `location`. */ addRule(params: Protocol.CSS.AddRuleRequest): Promise; /** * Returns all class names from specified stylesheet. */ collectClassNames(params: Protocol.CSS.CollectClassNamesRequest): Promise; /** * Creates a new special "via-inspector" stylesheet in the frame with given `frameId`. */ createStyleSheet(params: Protocol.CSS.CreateStyleSheetRequest): Promise; /** * Disables the CSS agent for the given page. */ disable(): Promise; /** * Enables the CSS agent for the given page. Clients should not assume that the CSS agent has been * enabled until the result of this command is received. */ enable(): Promise; /** * Ensures that the given node will have specified pseudo-classes whenever its style is computed by * the browser. */ forcePseudoState(params: Protocol.CSS.ForcePseudoStateRequest): Promise; /** * Ensures that the given node is in its starting-style state. */ forceStartingStyle(params: Protocol.CSS.ForceStartingStyleRequest): Promise; getBackgroundColors(params: Protocol.CSS.GetBackgroundColorsRequest): Promise; /** * Returns the computed style for a DOM node identified by `nodeId`. */ getComputedStyleForNode(params: Protocol.CSS.GetComputedStyleForNodeRequest): Promise; /** * Resolve the specified values in the context of the provided element. * For example, a value of '1em' is evaluated according to the computed * 'font-size' of the element and a value 'calc(1px + 2px)' will be * resolved to '3px'. * If the `propertyName` was specified the `values` are resolved as if * they were property's declaration. If a value cannot be parsed according * 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. * Note: this function currently does not resolve CSS random() function, * it returns unmodified random() function parts.` * @experimental */ resolveValues(params: Protocol.CSS.ResolveValuesRequest): Promise; /** * @experimental */ getLonghandProperties(params: Protocol.CSS.GetLonghandPropertiesRequest): Promise; /** * Returns the styles defined inline (explicitly in the "style" attribute and implicitly, using DOM * attributes) for a DOM node identified by `nodeId`. */ getInlineStylesForNode(params: Protocol.CSS.GetInlineStylesForNodeRequest): Promise; /** * Returns the styles coming from animations & transitions * including the animation & transition styles coming from inheritance chain. * @experimental */ getAnimatedStylesForNode(params: Protocol.CSS.GetAnimatedStylesForNodeRequest): Promise; /** * Returns requested styles for a DOM node identified by `nodeId`. */ getMatchedStylesForNode(params: Protocol.CSS.GetMatchedStylesForNodeRequest): Promise; /** * Returns the values of the default UA-defined environment variables used in env() * @experimental */ getEnvironmentVariables(): Promise; /** * Returns all media queries parsed by the rendering engine. */ getMediaQueries(): Promise; /** * Requests information about platform fonts which we used to render child TextNodes in the given * node. */ getPlatformFontsForNode(params: Protocol.CSS.GetPlatformFontsForNodeRequest): Promise; /** * Returns the current textual content for a stylesheet. */ getStyleSheetText(params: Protocol.CSS.GetStyleSheetTextRequest): Promise; /** * Returns all layers parsed by the rendering engine for the tree scope of a node. * 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 */ getLayersForNode(params: Protocol.CSS.GetLayersForNodeRequest): Promise; /** * 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 */ getLocationForSelector(params: Protocol.CSS.GetLocationForSelectorRequest): Promise; /** * Starts tracking the given node for the computed style updates * and whenever the computed style is updated for node, it queues * a `computedStyleUpdated` event with throttling. * 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 */ trackComputedStyleUpdatesForNode(params: Protocol.CSS.TrackComputedStyleUpdatesForNodeRequest): Promise; /** * Starts tracking the given computed styles for updates. The specified array of properties * replaces the one previously specified. Pass empty array to disable tracking. * Use takeComputedStyleUpdates to retrieve the list of nodes that had properties modified. * 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 */ trackComputedStyleUpdates(params: Protocol.CSS.TrackComputedStyleUpdatesRequest): Promise; /** * Polls the next batch of computed style updates. * @experimental */ takeComputedStyleUpdates(): Promise; /** * Find a rule with the given active property for the given node and set the new value for this * property */ setEffectivePropertyValueForNode(params: Protocol.CSS.SetEffectivePropertyValueForNodeRequest): Promise; /** * Modifies the property rule property name. */ setPropertyRulePropertyName(params: Protocol.CSS.SetPropertyRulePropertyNameRequest): Promise; /** * Modifies the keyframe rule key text. */ setKeyframeKey(params: Protocol.CSS.SetKeyframeKeyRequest): Promise; /** * Modifies the rule selector. */ setMediaText(params: Protocol.CSS.SetMediaTextRequest): Promise; /** * Modifies the expression of a container query. * @experimental */ setContainerQueryText(params: Protocol.CSS.SetContainerQueryTextRequest): Promise; /** * Modifies the expression of a supports at-rule. * @experimental */ setSupportsText(params: Protocol.CSS.SetSupportsTextRequest): Promise; /** * Modifies the expression of a navigation at-rule. * @experimental */ setNavigationText(params: Protocol.CSS.SetNavigationTextRequest): Promise; /** * Modifies the expression of a scope at-rule. * @experimental */ setScopeText(params: Protocol.CSS.SetScopeTextRequest): Promise; /** * Modifies the rule selector. */ setRuleSelector(params: Protocol.CSS.SetRuleSelectorRequest): Promise; /** * Sets the new stylesheet text. */ setStyleSheetText(params: Protocol.CSS.SetStyleSheetTextRequest): Promise; /** * Applies specified style edits one after another in the given order. */ setStyleTexts(params: Protocol.CSS.SetStyleTextsRequest): Promise; /** * Enables the selector recording. */ startRuleUsageTracking(): Promise; /** * Stop tracking rule usage and return the list of rules that were used since last call to * `takeCoverageDelta` (or since start of coverage instrumentation). */ stopRuleUsageTracking(): Promise; /** * Obtain list of rules that became used since last call to this method (or since start of coverage * instrumentation). */ takeCoverageDelta(): Promise; /** * Enables/disables rendering of local CSS fonts (enabled by default). * @experimental */ setLocalFontsEnabled(params: Protocol.CSS.SetLocalFontsEnabledRequest): Promise; /** * Fires whenever a web font is updated. A non-empty font parameter indicates a successfully loaded * web font. */ on(event: 'fontsUpdated', listener: (params: Protocol.CSS.FontsUpdatedEvent) => void): void; /** * Fires whenever a MediaQuery result changes (for example, after a browser window has been * resized.) The current implementation considers only viewport-dependent media features. */ on(event: 'mediaQueryResultChanged', listener: () => void): void; /** * Fired whenever an active document stylesheet is added. */ on(event: 'styleSheetAdded', listener: (params: Protocol.CSS.StyleSheetAddedEvent) => void): void; /** * Fired whenever a stylesheet is changed as a result of the client operation. */ on(event: 'styleSheetChanged', listener: (params: Protocol.CSS.StyleSheetChangedEvent) => void): void; /** * Fired whenever an active document stylesheet is removed. */ on(event: 'styleSheetRemoved', listener: (params: Protocol.CSS.StyleSheetRemovedEvent) => void): void; /** * @experimental */ on(event: 'computedStyleUpdated', listener: (params: Protocol.CSS.ComputedStyleUpdatedEvent) => void): void; } export interface CacheStorageApi { /** * Deletes a cache. */ deleteCache(params: Protocol.CacheStorage.DeleteCacheRequest): Promise; /** * Deletes a cache entry. */ deleteEntry(params: Protocol.CacheStorage.DeleteEntryRequest): Promise; /** * Requests cache names. */ requestCacheNames(params: Protocol.CacheStorage.RequestCacheNamesRequest): Promise; /** * Fetches cache entry. */ requestCachedResponse(params: Protocol.CacheStorage.RequestCachedResponseRequest): Promise; /** * Requests data from cache. */ requestEntries(params: Protocol.CacheStorage.RequestEntriesRequest): Promise; } export interface CastApi { /** * Starts observing for sinks that can be used for tab mirroring, and if set, * sinks compatible with |presentationUrl| as well. When sinks are found, a * |sinksUpdated| event is fired. * Also starts observing for issue messages. When an issue is added or removed, * an |issueUpdated| event is fired. */ enable(params: Protocol.Cast.EnableRequest): Promise; /** * Stops observing for sinks and issues. */ disable(): Promise; /** * Sets a sink to be used when the web page requests the browser to choose a * sink via Presentation API, Remote Playback API, or Cast SDK. */ setSinkToUse(params: Protocol.Cast.SetSinkToUseRequest): Promise; /** * Starts mirroring the desktop to the sink. */ startDesktopMirroring(params: Protocol.Cast.StartDesktopMirroringRequest): Promise; /** * Starts mirroring the tab to the sink. */ startTabMirroring(params: Protocol.Cast.StartTabMirroringRequest): Promise; /** * Stops the active Cast session on the sink. */ stopCasting(params: Protocol.Cast.StopCastingRequest): Promise; /** * This is fired whenever the list of available sinks changes. A sink is a * device or a software surface that you can cast to. */ on(event: 'sinksUpdated', listener: (params: Protocol.Cast.SinksUpdatedEvent) => void): void; /** * This is fired whenever the outstanding issue/error message changes. * |issueMessage| is empty if there is no issue. */ on(event: 'issueUpdated', listener: (params: Protocol.Cast.IssueUpdatedEvent) => void): void; } export interface DOMApi { /** * Collects class names for the node with given id and all of it's child nodes. * @experimental */ collectClassNamesFromSubtree(params: Protocol.DOM.CollectClassNamesFromSubtreeRequest): Promise; /** * Creates a deep copy of the specified node and places it into the target container before the * given anchor. * @experimental */ copyTo(params: Protocol.DOM.CopyToRequest): Promise; /** * Describes node given its id, does not require domain to be enabled. Does not start tracking any * objects, can be used for automation. */ describeNode(params: Protocol.DOM.DescribeNodeRequest): Promise; /** * Scrolls the specified rect of the given node into view if not already visible. * Note: exactly one between nodeId, backendNodeId and objectId should be passed * to identify the node. */ scrollIntoViewIfNeeded(params: Protocol.DOM.ScrollIntoViewIfNeededRequest): Promise; /** * Disables DOM agent for the given page. */ disable(): Promise; /** * Discards search results from the session with the given id. `getSearchResults` should no longer * be called for that search. * @experimental */ discardSearchResults(params: Protocol.DOM.DiscardSearchResultsRequest): Promise; /** * Enables DOM agent for the given page. */ enable(params: Protocol.DOM.EnableRequest): Promise; /** * Focuses the given element. */ focus(params: Protocol.DOM.FocusRequest): Promise; /** * Returns attributes for the specified node. */ getAttributes(params: Protocol.DOM.GetAttributesRequest): Promise; /** * Returns boxes for the given node. */ getBoxModel(params: Protocol.DOM.GetBoxModelRequest): Promise; /** * Returns quads that describe node position on the page. This method * might return multiple quads for inline nodes. * @experimental */ getContentQuads(params: Protocol.DOM.GetContentQuadsRequest): Promise; /** * Returns the root DOM node (and optionally the subtree) to the caller. * Implicitly enables the DOM domain events for the current target. */ getDocument(params: Protocol.DOM.GetDocumentRequest): Promise; /** * 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 */ getFlattenedDocument(params: Protocol.DOM.GetFlattenedDocumentRequest): Promise; /** * Finds nodes with a given computed style in a subtree. * @experimental */ getNodesForSubtreeByStyle(params: Protocol.DOM.GetNodesForSubtreeByStyleRequest): Promise; /** * Returns node id at given location. Depending on whether DOM domain is enabled, nodeId is * either returned or not. */ getNodeForLocation(params: Protocol.DOM.GetNodeForLocationRequest): Promise; /** * Returns node's HTML markup. */ getOuterHTML(params: Protocol.DOM.GetOuterHTMLRequest): Promise; /** * Returns the id of the nearest ancestor that is a relayout boundary. * @experimental */ getRelayoutBoundary(params: Protocol.DOM.GetRelayoutBoundaryRequest): Promise; /** * Returns search results from given `fromIndex` to given `toIndex` from the search with the given * identifier. * @experimental */ getSearchResults(params: Protocol.DOM.GetSearchResultsRequest): Promise; /** * Hides any highlight. */ hideHighlight(): Promise; /** * Highlights DOM node. */ highlightNode(): Promise; /** * Highlights given rectangle. */ highlightRect(): Promise; /** * Marks last undoable state. * @experimental */ markUndoableState(): Promise; /** * Moves node into the new container, places it before the given anchor. */ moveTo(params: Protocol.DOM.MoveToRequest): Promise; /** * Searches for a given string in the DOM tree. Use `getSearchResults` to access search results or * `cancelSearch` to end this search session. * @experimental */ performSearch(params: Protocol.DOM.PerformSearchRequest): Promise; /** * Requests that the node is sent to the caller given its path. // FIXME, use XPath * @experimental */ pushNodeByPathToFrontend(params: Protocol.DOM.PushNodeByPathToFrontendRequest): Promise; /** * Requests that a batch of nodes is sent to the caller given their backend node ids. * @experimental */ pushNodesByBackendIdsToFrontend(params: Protocol.DOM.PushNodesByBackendIdsToFrontendRequest): Promise; /** * Executes `querySelector` on a given node. */ querySelector(params: Protocol.DOM.QuerySelectorRequest): Promise; /** * Executes `querySelectorAll` on a given node. */ querySelectorAll(params: Protocol.DOM.QuerySelectorAllRequest): Promise; /** * 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 */ getTopLayerElements(): Promise; /** * Returns the NodeId of the matched element according to certain relations. * @experimental */ getElementByRelation(params: Protocol.DOM.GetElementByRelationRequest): Promise; /** * Re-does the last undone action. * @experimental */ redo(): Promise; /** * Removes attribute with given name from an element with given id. */ removeAttribute(params: Protocol.DOM.RemoveAttributeRequest): Promise; /** * Removes node with given id. */ removeNode(params: Protocol.DOM.RemoveNodeRequest): Promise; /** * Requests that children of the node with given id are returned to the caller in form of * `setChildNodes` events where not only immediate children are retrieved, but all children down to * the specified depth. */ requestChildNodes(params: Protocol.DOM.RequestChildNodesRequest): Promise; /** * Requests that the node is sent to the caller given the JavaScript node object reference. All * nodes that form the path from the node to the root are also sent to the client as a series of * `setChildNodes` notifications. */ requestNode(params: Protocol.DOM.RequestNodeRequest): Promise; /** * Resolves the JavaScript node object for a given NodeId or BackendNodeId. */ resolveNode(params: Protocol.DOM.ResolveNodeRequest): Promise; /** * Sets attribute for an element with given id. */ setAttributeValue(params: Protocol.DOM.SetAttributeValueRequest): Promise; /** * Sets attributes on element with given id. This method is useful when user edits some existing * attribute value and types in several attribute name/value pairs. */ setAttributesAsText(params: Protocol.DOM.SetAttributesAsTextRequest): Promise; /** * Sets files for the given file input element. */ setFileInputFiles(params: Protocol.DOM.SetFileInputFilesRequest): Promise; /** * Sets if stack traces should be captured for Nodes. See `Node.getNodeStackTraces`. Default is disabled. * @experimental */ setNodeStackTracesEnabled(params: Protocol.DOM.SetNodeStackTracesEnabledRequest): Promise; /** * Gets stack traces associated with a Node. As of now, only provides stack trace for Node creation. * @experimental */ getNodeStackTraces(params: Protocol.DOM.GetNodeStackTracesRequest): Promise; /** * Returns file information for the given * File wrapper. * @experimental */ getFileInfo(params: Protocol.DOM.GetFileInfoRequest): Promise; /** * Returns list of detached nodes * @experimental */ getDetachedDomNodes(): Promise; /** * Enables console to refer to the node with given id via $x (see Command Line API for more details * $x functions). * @experimental */ setInspectedNode(params: Protocol.DOM.SetInspectedNodeRequest): Promise; /** * Sets node name for a node with given id. */ setNodeName(params: Protocol.DOM.SetNodeNameRequest): Promise; /** * Sets node value for a node with given id. */ setNodeValue(params: Protocol.DOM.SetNodeValueRequest): Promise; /** * Sets node HTML markup, returns new node id. */ setOuterHTML(params: Protocol.DOM.SetOuterHTMLRequest): Promise; /** * Undoes the last performed action. * @experimental */ undo(): Promise; /** * Returns iframe node that owns iframe with the given domain. * @experimental */ getFrameOwner(params: Protocol.DOM.GetFrameOwnerRequest): Promise; /** * Returns the query container of the given node based on container query * conditions: containerName, physical and logical axes, and whether it queries * 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 */ getContainerForNode(params: Protocol.DOM.GetContainerForNodeRequest): Promise; /** * Returns the descendants of a container query container that have * container queries against this container. * @experimental */ getQueryingDescendantsForContainer(params: Protocol.DOM.GetQueryingDescendantsForContainerRequest): Promise; /** * Returns the target anchor element of the given anchor query according to * https://www.w3.org/TR/css-anchor-position-1/#target. * @experimental */ getAnchorElement(params: Protocol.DOM.GetAnchorElementRequest): Promise; /** * When enabling, this API force-opens the popover identified by nodeId * and keeps it open until disabled. * @experimental */ forceShowPopover(params: Protocol.DOM.ForceShowPopoverRequest): Promise; /** * Fired when `Element`'s attribute is modified. */ on(event: 'attributeModified', listener: (params: Protocol.DOM.AttributeModifiedEvent) => void): void; /** * Fired when `Element`'s adoptedStyleSheets are modified. * @experimental */ on(event: 'adoptedStyleSheetsModified', listener: (params: Protocol.DOM.AdoptedStyleSheetsModifiedEvent) => void): void; /** * Fired when `Element`'s attribute is removed. */ on(event: 'attributeRemoved', listener: (params: Protocol.DOM.AttributeRemovedEvent) => void): void; /** * Mirrors `DOMCharacterDataModified` event. */ on(event: 'characterDataModified', listener: (params: Protocol.DOM.CharacterDataModifiedEvent) => void): void; /** * Fired when `Container`'s child node count has changed. */ on(event: 'childNodeCountUpdated', listener: (params: Protocol.DOM.ChildNodeCountUpdatedEvent) => void): void; /** * Mirrors `DOMNodeInserted` event. */ on(event: 'childNodeInserted', listener: (params: Protocol.DOM.ChildNodeInsertedEvent) => void): void; /** * Mirrors `DOMNodeRemoved` event. */ on(event: 'childNodeRemoved', listener: (params: Protocol.DOM.ChildNodeRemovedEvent) => void): void; /** * Called when distribution is changed. * @experimental */ on(event: 'distributedNodesUpdated', listener: (params: Protocol.DOM.DistributedNodesUpdatedEvent) => void): void; /** * Fired when `Document` has been totally updated. Node ids are no longer valid. */ on(event: 'documentUpdated', listener: () => void): void; /** * Fired when `Element`'s inline style is modified via a CSS property modification. * @experimental */ on(event: 'inlineStyleInvalidated', listener: (params: Protocol.DOM.InlineStyleInvalidatedEvent) => void): void; /** * Called when a pseudo element is added to an element. * @experimental */ on(event: 'pseudoElementAdded', listener: (params: Protocol.DOM.PseudoElementAddedEvent) => void): void; /** * Called when top layer elements are changed. * @experimental */ on(event: 'topLayerElementsUpdated', listener: () => void): void; /** * Fired when a node's scrollability state changes. * @experimental */ on(event: 'scrollableFlagUpdated', listener: (params: Protocol.DOM.ScrollableFlagUpdatedEvent) => void): void; /** * Fired when a node's ad related state changes. * @experimental */ on(event: 'adRelatedStateUpdated', listener: (params: Protocol.DOM.AdRelatedStateUpdatedEvent) => void): void; /** * Fired when a node's starting styles changes. * @experimental */ on(event: 'affectedByStartingStylesFlagUpdated', listener: (params: Protocol.DOM.AffectedByStartingStylesFlagUpdatedEvent) => void): void; /** * Called when a pseudo element is removed from an element. * @experimental */ on(event: 'pseudoElementRemoved', listener: (params: Protocol.DOM.PseudoElementRemovedEvent) => void): void; /** * Fired when backend wants to provide client with the missing DOM structure. This happens upon * most of the calls requesting node ids. */ on(event: 'setChildNodes', listener: (params: Protocol.DOM.SetChildNodesEvent) => void): void; /** * Called when shadow root is popped from the element. * @experimental */ on(event: 'shadowRootPopped', listener: (params: Protocol.DOM.ShadowRootPoppedEvent) => void): void; /** * Called when shadow root is pushed into the element. * @experimental */ on(event: 'shadowRootPushed', listener: (params: Protocol.DOM.ShadowRootPushedEvent) => void): void; } export interface DOMDebuggerApi { /** * Returns event listeners of the given object. */ getEventListeners(params: Protocol.DOMDebugger.GetEventListenersRequest): Promise; /** * Removes DOM breakpoint that was set using `setDOMBreakpoint`. */ removeDOMBreakpoint(params: Protocol.DOMDebugger.RemoveDOMBreakpointRequest): Promise; /** * Removes breakpoint on particular DOM event. */ removeEventListenerBreakpoint(params: Protocol.DOMDebugger.RemoveEventListenerBreakpointRequest): Promise; /** * Removes breakpoint on particular native event. * @deprecated * @experimental */ removeInstrumentationBreakpoint(params: Protocol.DOMDebugger.RemoveInstrumentationBreakpointRequest): Promise; /** * Removes breakpoint from XMLHttpRequest. */ removeXHRBreakpoint(params: Protocol.DOMDebugger.RemoveXHRBreakpointRequest): Promise; /** * Sets breakpoint on particular CSP violations. * @experimental */ setBreakOnCSPViolation(params: Protocol.DOMDebugger.SetBreakOnCSPViolationRequest): Promise; /** * Sets breakpoint on particular operation with DOM. */ setDOMBreakpoint(params: Protocol.DOMDebugger.SetDOMBreakpointRequest): Promise; /** * Sets breakpoint on particular DOM event. */ setEventListenerBreakpoint(params: Protocol.DOMDebugger.SetEventListenerBreakpointRequest): Promise; /** * Sets breakpoint on particular native event. * @deprecated * @experimental */ setInstrumentationBreakpoint(params: Protocol.DOMDebugger.SetInstrumentationBreakpointRequest): Promise; /** * Sets breakpoint on XMLHttpRequest. */ setXHRBreakpoint(params: Protocol.DOMDebugger.SetXHRBreakpointRequest): Promise; } export interface DOMSnapshotApi { /** * Disables DOM snapshot agent for the given page. */ disable(): Promise; /** * Enables DOM snapshot agent for the given page. */ enable(): Promise; /** * Returns a document snapshot, including the full DOM tree of the root node (including iframes, * 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 */ getSnapshot(params: Protocol.DOMSnapshot.GetSnapshotRequest): Promise; /** * Returns a document snapshot, including the full DOM tree of the root node (including iframes, * 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. */ captureSnapshot(params: Protocol.DOMSnapshot.CaptureSnapshotRequest): Promise; } export interface DOMStorageApi { clear(params: Protocol.DOMStorage.ClearRequest): Promise; /** * Disables storage tracking, prevents storage events from being sent to the client. */ disable(): Promise; /** * Enables storage tracking, storage events will now be delivered to the client. */ enable(): Promise; getDOMStorageItems(params: Protocol.DOMStorage.GetDOMStorageItemsRequest): Promise; removeDOMStorageItem(params: Protocol.DOMStorage.RemoveDOMStorageItemRequest): Promise; setDOMStorageItem(params: Protocol.DOMStorage.SetDOMStorageItemRequest): Promise; on(event: 'domStorageItemAdded', listener: (params: Protocol.DOMStorage.DomStorageItemAddedEvent) => void): void; on(event: 'domStorageItemRemoved', listener: (params: Protocol.DOMStorage.DomStorageItemRemovedEvent) => void): void; on(event: 'domStorageItemUpdated', listener: (params: Protocol.DOMStorage.DomStorageItemUpdatedEvent) => void): void; on(event: 'domStorageItemsCleared', listener: (params: Protocol.DOMStorage.DomStorageItemsClearedEvent) => void): void; } export interface DeviceAccessApi { /** * Enable events in this domain. */ enable(): Promise; /** * Disable events in this domain. */ disable(): Promise; /** * Select a device in response to a DeviceAccess.deviceRequestPrompted event. */ selectPrompt(params: Protocol.DeviceAccess.SelectPromptRequest): Promise; /** * Cancel a prompt in response to a DeviceAccess.deviceRequestPrompted event. */ cancelPrompt(params: Protocol.DeviceAccess.CancelPromptRequest): Promise; /** * A device request opened a user prompt to select a device. Respond with the * selectPrompt or cancelPrompt command. */ on(event: 'deviceRequestPrompted', listener: (params: Protocol.DeviceAccess.DeviceRequestPromptedEvent) => void): void; } export interface DeviceOrientationApi { /** * Clears the overridden Device Orientation. */ clearDeviceOrientationOverride(): Promise; /** * Overrides the Device Orientation. */ setDeviceOrientationOverride(params: Protocol.DeviceOrientation.SetDeviceOrientationOverrideRequest): Promise; } export interface EmulationApi { /** * Tells whether emulation is supported. * @deprecated */ canEmulate(): Promise; /** * Clears the overridden device metrics. */ clearDeviceMetricsOverride(): Promise; /** * Clears the overridden Geolocation Position and Error. */ clearGeolocationOverride(): Promise; /** * Requests that page scale factor is reset to initial values. * @experimental */ resetPageScaleFactor(): Promise; /** * Enables or disables simulating a focused and active page. * @experimental */ setFocusEmulationEnabled(params: Protocol.Emulation.SetFocusEmulationEnabledRequest): Promise; /** * Automatically render all web contents using a dark theme. * @experimental */ setAutoDarkModeOverride(params: Protocol.Emulation.SetAutoDarkModeOverrideRequest): Promise; /** * Enables CPU throttling to emulate slow CPUs. */ setCPUThrottlingRate(params: Protocol.Emulation.SetCPUThrottlingRateRequest): Promise; /** * Sets or clears an override of the default background color of the frame. This override is used * if the content does not specify one. */ setDefaultBackgroundColorOverride(params: Protocol.Emulation.SetDefaultBackgroundColorOverrideRequest): Promise; /** * 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 */ setSafeAreaInsetsOverride(params: Protocol.Emulation.SetSafeAreaInsetsOverrideRequest): Promise; /** * 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). */ setDeviceMetricsOverride(params: Protocol.Emulation.SetDeviceMetricsOverrideRequest): Promise; /** * Start reporting the given posture value to the Device Posture API. * This override can also be set in setDeviceMetricsOverride(). * @experimental */ setDevicePostureOverride(params: Protocol.Emulation.SetDevicePostureOverrideRequest): Promise; /** * Clears a device posture override set with either setDeviceMetricsOverride() * or setDevicePostureOverride() and starts using posture information from the * platform again. * Does nothing if no override is set. * @experimental */ clearDevicePostureOverride(): Promise; /** * Start using the given display features to pupulate the Viewport Segments API. * This override can also be set in setDeviceMetricsOverride(). * @experimental */ setDisplayFeaturesOverride(params: Protocol.Emulation.SetDisplayFeaturesOverrideRequest): Promise; /** * Clears the display features override set with either setDeviceMetricsOverride() * or setDisplayFeaturesOverride() and starts using display features from the * platform again. * Does nothing if no override is set. * @experimental */ clearDisplayFeaturesOverride(): Promise; /** * @experimental */ setScrollbarsHidden(params: Protocol.Emulation.SetScrollbarsHiddenRequest): Promise; /** * @experimental */ setDocumentCookieDisabled(params: Protocol.Emulation.SetDocumentCookieDisabledRequest): Promise; /** * @experimental */ setEmitTouchEventsForMouse(params: Protocol.Emulation.SetEmitTouchEventsForMouseRequest): Promise; /** * Emulates the given media type or media feature for CSS media queries. */ setEmulatedMedia(params: Protocol.Emulation.SetEmulatedMediaRequest): Promise; /** * Emulates the given vision deficiency. */ setEmulatedVisionDeficiency(params: Protocol.Emulation.SetEmulatedVisionDeficiencyRequest): Promise; /** * Emulates the given OS text scale. */ setEmulatedOSTextScale(params: Protocol.Emulation.SetEmulatedOSTextScaleRequest): Promise; /** * Overrides the Geolocation Position or Error. Omitting latitude, longitude or * accuracy emulates position unavailable. */ setGeolocationOverride(params: Protocol.Emulation.SetGeolocationOverrideRequest): Promise; /** * @experimental */ getOverriddenSensorInformation(params: Protocol.Emulation.GetOverriddenSensorInformationRequest): Promise; /** * Overrides a platform sensor of a given type. If |enabled| is true, calls to * Sensor.start() will use a virtual sensor as backend rather than fetching * 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 */ setSensorOverrideEnabled(params: Protocol.Emulation.SetSensorOverrideEnabledRequest): Promise; /** * Updates the sensor readings reported by a sensor type previously overridden * by setSensorOverrideEnabled. * @experimental */ setSensorOverrideReadings(params: Protocol.Emulation.SetSensorOverrideReadingsRequest): Promise; /** * Overrides a pressure source of a given type, as used by the Compute * Pressure API, so that updates to PressureObserver.observe() are provided * via setPressureStateOverride instead of being retrieved from * platform-provided telemetry data. * @experimental */ setPressureSourceOverrideEnabled(params: Protocol.Emulation.SetPressureSourceOverrideEnabledRequest): Promise; /** * TODO: OBSOLETE: To remove when setPressureDataOverride is merged. * 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 */ setPressureStateOverride(params: Protocol.Emulation.SetPressureStateOverrideRequest): Promise; /** * 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 */ setPressureDataOverride(params: Protocol.Emulation.SetPressureDataOverrideRequest): Promise; /** * Overrides the Idle state. */ setIdleOverride(params: Protocol.Emulation.SetIdleOverrideRequest): Promise; /** * Clears Idle state overrides. */ clearIdleOverride(): Promise; /** * Overrides value returned by the javascript navigator object. * @deprecated * @experimental */ setNavigatorOverrides(params: Protocol.Emulation.SetNavigatorOverridesRequest): Promise; /** * Sets a specified page scale factor. * @experimental */ setPageScaleFactor(params: Protocol.Emulation.SetPageScaleFactorRequest): Promise; /** * Switches script execution in the page. */ setScriptExecutionDisabled(params: Protocol.Emulation.SetScriptExecutionDisabledRequest): Promise; /** * Enables touch on platforms which do not support them. */ setTouchEmulationEnabled(params: Protocol.Emulation.SetTouchEmulationEnabledRequest): Promise; /** * 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 */ setVirtualTimePolicy(params: Protocol.Emulation.SetVirtualTimePolicyRequest): Promise; /** * Overrides default host system locale with the specified one. * @experimental */ setLocaleOverride(params: Protocol.Emulation.SetLocaleOverrideRequest): Promise; /** * Overrides default host system timezone with the specified one. */ setTimezoneOverride(params: Protocol.Emulation.SetTimezoneOverrideRequest): Promise; /** * 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 */ setVisibleSize(params: Protocol.Emulation.SetVisibleSizeRequest): Promise; /** * @experimental */ setDisabledImageTypes(params: Protocol.Emulation.SetDisabledImageTypesRequest): Promise; /** * Override the value of navigator.connection.saveData * @experimental */ setDataSaverOverride(params: Protocol.Emulation.SetDataSaverOverrideRequest): Promise; /** * @experimental */ setHardwareConcurrencyOverride(params: Protocol.Emulation.SetHardwareConcurrencyOverrideRequest): Promise; /** * Allows overriding user agent with the given string. * `userAgentMetadata` must be set for Client Hint headers to be sent. */ setUserAgentOverride(params: Protocol.Emulation.SetUserAgentOverrideRequest): Promise; /** * Allows overriding the automation flag. * @experimental */ setAutomationOverride(params: Protocol.Emulation.SetAutomationOverrideRequest): Promise; /** * 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 */ setSmallViewportHeightDifferenceOverride(params: Protocol.Emulation.SetSmallViewportHeightDifferenceOverrideRequest): Promise; /** * Returns device's screen configuration. In headful mode, the physical screens configuration is returned, * whereas in headless mode, a virtual headless screen configuration is provided instead. * @experimental */ getScreenInfos(): Promise; /** * Add a new screen to the device. Only supported in headless mode. * @experimental */ addScreen(params: Protocol.Emulation.AddScreenRequest): Promise; /** * Updates specified screen parameters. Only supported in headless mode. * @experimental */ updateScreen(params: Protocol.Emulation.UpdateScreenRequest): Promise; /** * Remove screen from the device. Only supported in headless mode. * @experimental */ removeScreen(params: Protocol.Emulation.RemoveScreenRequest): Promise; /** * Set primary screen. Only supported in headless mode. * Note that this changes the coordinate system origin to the top-left * of the new primary screen, updating the bounds and work areas * of all existing screens accordingly. * @experimental */ setPrimaryScreen(params: Protocol.Emulation.SetPrimaryScreenRequest): Promise; /** * Notification sent after the virtual time budget for the current VirtualTimePolicy has run out. * @experimental */ on(event: 'virtualTimeBudgetExpired', listener: () => void): void; /** * 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 */ on(event: 'screenOrientationLockChanged', listener: (params: Protocol.Emulation.ScreenOrientationLockChangedEvent) => void): void; } export interface EventBreakpointsApi { /** * Sets breakpoint on particular native event. */ setInstrumentationBreakpoint(params: Protocol.EventBreakpoints.SetInstrumentationBreakpointRequest): Promise; /** * Removes breakpoint on particular native event. */ removeInstrumentationBreakpoint(params: Protocol.EventBreakpoints.RemoveInstrumentationBreakpointRequest): Promise; /** * Removes all breakpoints */ disable(): Promise; } export interface ExtensionsApi { /** * Runs an extension default action. * Available if the client is connected using the --remote-debugging-pipe * flag and the --enable-unsafe-extension-debugging flag is set. */ triggerAction(params: Protocol.Extensions.TriggerActionRequest): Promise; /** * Installs an unpacked extension from the filesystem similar to * --load-extension CLI flags. Returns extension ID once the extension * has been installed. Available if the client is connected using the * --remote-debugging-pipe flag and the --enable-unsafe-extension-debugging * flag is set. */ loadUnpacked(params: Protocol.Extensions.LoadUnpackedRequest): Promise; /** * Gets a list of all unpacked extensions. * Available if the client is connected using the --remote-debugging-pipe flag * and the --enable-unsafe-extension-debugging flag is set. */ getExtensions(): Promise; /** * Uninstalls an unpacked extension (others not supported) from the profile. * Available if the client is connected using the --remote-debugging-pipe flag * and the --enable-unsafe-extension-debugging. */ uninstall(params: Protocol.Extensions.UninstallRequest): Promise; /** * Gets data from extension storage in the given `storageArea`. If `keys` is * specified, these are used to filter the result. */ getStorageItems(params: Protocol.Extensions.GetStorageItemsRequest): Promise; /** * Removes `keys` from extension storage in the given `storageArea`. */ removeStorageItems(params: Protocol.Extensions.RemoveStorageItemsRequest): Promise; /** * Clears extension storage in the given `storageArea`. */ clearStorageItems(params: Protocol.Extensions.ClearStorageItemsRequest): Promise; /** * Sets `values` in extension storage in the given `storageArea`. The provided `values` * will be merged with existing values in the storage area. */ setStorageItems(params: Protocol.Extensions.SetStorageItemsRequest): Promise; } export interface FedCmApi { enable(params: Protocol.FedCm.EnableRequest): Promise; disable(): Promise; selectAccount(params: Protocol.FedCm.SelectAccountRequest): Promise; clickDialogButton(params: Protocol.FedCm.ClickDialogButtonRequest): Promise; openUrl(params: Protocol.FedCm.OpenUrlRequest): Promise; dismissDialog(params: Protocol.FedCm.DismissDialogRequest): Promise; /** * Resets the cooldown time, if any, to allow the next FedCM call to show * a dialog even if one was recently dismissed by the user. */ resetCooldown(): Promise; on(event: 'dialogShown', listener: (params: Protocol.FedCm.DialogShownEvent) => void): void; /** * Triggered when a dialog is closed, either by user action, JS abort, * or a command below. */ on(event: 'dialogClosed', listener: (params: Protocol.FedCm.DialogClosedEvent) => void): void; } export interface FetchApi { /** * Disables the fetch domain. */ disable(): Promise; /** * Enables issuing of requestPaused events. A request will be paused until client * calls one of failRequest, fulfillRequest or continueRequest/continueWithAuth. */ enable(params: Protocol.Fetch.EnableRequest): Promise; /** * Causes the request to fail with specified reason. */ failRequest(params: Protocol.Fetch.FailRequestRequest): Promise; /** * Provides response to the request. */ fulfillRequest(params: Protocol.Fetch.FulfillRequestRequest): Promise; /** * Continues the request, optionally modifying some of its parameters. */ continueRequest(params: Protocol.Fetch.ContinueRequestRequest): Promise; /** * Continues a request supplying authChallengeResponse following authRequired event. */ continueWithAuth(params: Protocol.Fetch.ContinueWithAuthRequest): Promise; /** * Continues loading of the paused response, optionally modifying the * response headers. If either responseCode or headers are modified, all of them * must be present. * @experimental */ continueResponse(params: Protocol.Fetch.ContinueResponseRequest): Promise; /** * Causes the body of the response to be received from the server and * returned as a single string. May only be issued for a request that * is paused in the Response stage and is mutually exclusive with * takeResponseBodyForInterceptionAsStream. Calling other methods that * affect the request or disabling fetch domain before body is received * results in an undefined behavior. * Note that the response body is not available for redirects. Requests * paused in the _redirect received_ state may be differentiated by * `responseCode` and presence of `location` response header, see * comments to `requestPaused` for details. */ getResponseBody(params: Protocol.Fetch.GetResponseBodyRequest): Promise; /** * Returns a handle to the stream representing the response body. * The request must be paused in the HeadersReceived stage. * Note that after this command the request can't be continued * as is -- client either needs to cancel it or to provide the * response body. * The stream only supports sequential read, IO.read will fail if the position * is specified. * This method is mutually exclusive with getResponseBody. * Calling other methods that affect the request or disabling fetch * domain before body is received results in an undefined behavior. */ takeResponseBodyAsStream(params: Protocol.Fetch.TakeResponseBodyAsStreamRequest): Promise; /** * 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. */ on(event: 'requestPaused', listener: (params: Protocol.Fetch.RequestPausedEvent) => void): void; /** * Issued when the domain is enabled with handleAuthRequests set to true. * The request is paused until client responds with continueWithAuth. */ on(event: 'authRequired', listener: (params: Protocol.Fetch.AuthRequiredEvent) => void): void; } export interface FileSystemApi { getDirectory(params: Protocol.FileSystem.GetDirectoryRequest): Promise; } export interface HeadlessExperimentalApi { /** * Sends a BeginFrame to the target and returns when the frame was completed. Optionally captures a * screenshot from the resulting frame. Requires that the target was created with enabled * BeginFrameControl. Designed for use with --run-all-compositor-stages-before-draw, see also * https://goo.gle/chrome-headless-rendering for more background. */ beginFrame(params: Protocol.HeadlessExperimental.BeginFrameRequest): Promise; /** * Disables headless events for the target. * @deprecated */ disable(): Promise; /** * Enables headless events for the target. * @deprecated */ enable(): Promise; } export interface IOApi { /** * Close the stream, discard any temporary backing storage. */ close(params: Protocol.IO.CloseRequest): Promise; /** * Read a chunk of the stream */ read(params: Protocol.IO.ReadRequest): Promise; /** * Return UUID of Blob object specified by a remote object id. */ resolveBlob(params: Protocol.IO.ResolveBlobRequest): Promise; } export interface IndexedDBApi { /** * Clears all entries from an object store. */ clearObjectStore(params: Protocol.IndexedDB.ClearObjectStoreRequest): Promise; /** * Deletes a database. */ deleteDatabase(params: Protocol.IndexedDB.DeleteDatabaseRequest): Promise; /** * Delete a range of entries from an object store */ deleteObjectStoreEntries(params: Protocol.IndexedDB.DeleteObjectStoreEntriesRequest): Promise; /** * Disables events from backend. */ disable(): Promise; /** * Enables events from backend. */ enable(): Promise; /** * Requests data from object store or index. */ requestData(params: Protocol.IndexedDB.RequestDataRequest): Promise; /** * Gets metadata of an object store. */ getMetadata(params: Protocol.IndexedDB.GetMetadataRequest): Promise; /** * Requests database with given name in given frame. */ requestDatabase(params: Protocol.IndexedDB.RequestDatabaseRequest): Promise; /** * Requests database names for given security origin. */ requestDatabaseNames(params: Protocol.IndexedDB.RequestDatabaseNamesRequest): Promise; } export interface InputApi { /** * Dispatches a drag event into the page. * @experimental */ dispatchDragEvent(params: Protocol.Input.DispatchDragEventRequest): Promise; /** * Dispatches a key event to the page. */ dispatchKeyEvent(params: Protocol.Input.DispatchKeyEventRequest): Promise; /** * This method emulates inserting text that doesn't come from a key press, * for example an emoji keyboard or an IME. * @experimental */ insertText(params: Protocol.Input.InsertTextRequest): Promise; /** * 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 */ imeSetComposition(params: Protocol.Input.ImeSetCompositionRequest): Promise; /** * Dispatches a mouse event to the page. */ dispatchMouseEvent(params: Protocol.Input.DispatchMouseEventRequest): Promise; /** * Dispatches a touch event to the page. */ dispatchTouchEvent(params: Protocol.Input.DispatchTouchEventRequest): Promise; /** * Cancels any active dragging in the page. */ cancelDragging(): Promise; /** * Emulates touch event from the mouse event parameters. * @experimental */ emulateTouchFromMouseEvent(params: Protocol.Input.EmulateTouchFromMouseEventRequest): Promise; /** * Ignores input events (useful while auditing page). */ setIgnoreInputEvents(params: Protocol.Input.SetIgnoreInputEventsRequest): Promise; /** * Prevents default drag and drop behavior and instead emits `Input.dragIntercepted` events. * Drag and drop behavior can be directly controlled via `Input.dispatchDragEvent`. * @experimental */ setInterceptDrags(params: Protocol.Input.SetInterceptDragsRequest): Promise; /** * Synthesizes a pinch gesture over a time period by issuing appropriate touch events. * @experimental */ synthesizePinchGesture(params: Protocol.Input.SynthesizePinchGestureRequest): Promise; /** * Synthesizes a scroll gesture over a time period by issuing appropriate touch events. * @experimental */ synthesizeScrollGesture(params: Protocol.Input.SynthesizeScrollGestureRequest): Promise; /** * Synthesizes a tap gesture over a time period by issuing appropriate touch events. * @experimental */ synthesizeTapGesture(params: Protocol.Input.SynthesizeTapGestureRequest): Promise; /** * Emitted only when `Input.setInterceptDrags` is enabled. Use this data with `Input.dispatchDragEvent` to * restore normal drag and drop behavior. * @experimental */ on(event: 'dragIntercepted', listener: (params: Protocol.Input.DragInterceptedEvent) => void): void; } export interface InspectorApi { /** * Disables inspector domain notifications. */ disable(): Promise; /** * Enables inspector domain notifications. */ enable(): Promise; /** * Fired when remote debugging connection is about to be terminated. Contains detach reason. */ on(event: 'detached', listener: (params: Protocol.Inspector.DetachedEvent) => void): void; /** * Fired when debugging target has crashed */ on(event: 'targetCrashed', listener: () => void): void; /** * Fired when debugging target has reloaded after crash */ on(event: 'targetReloadedAfterCrash', listener: () => void): void; /** * Fired on worker targets when main worker script and any imported scripts have been evaluated. * @experimental */ on(event: 'workerScriptLoaded', listener: () => void): void; } export interface LayerTreeApi { /** * Provides the reasons why the given layer was composited. */ compositingReasons(params: Protocol.LayerTree.CompositingReasonsRequest): Promise; /** * Disables compositing tree inspection. */ disable(): Promise; /** * Enables compositing tree inspection. */ enable(): Promise; /** * Returns the snapshot identifier. */ loadSnapshot(params: Protocol.LayerTree.LoadSnapshotRequest): Promise; /** * Returns the layer snapshot identifier. */ makeSnapshot(params: Protocol.LayerTree.MakeSnapshotRequest): Promise; profileSnapshot(params: Protocol.LayerTree.ProfileSnapshotRequest): Promise; /** * Releases layer snapshot captured by the back-end. */ releaseSnapshot(params: Protocol.LayerTree.ReleaseSnapshotRequest): Promise; /** * Replays the layer snapshot and returns the resulting bitmap. */ replaySnapshot(params: Protocol.LayerTree.ReplaySnapshotRequest): Promise; /** * Replays the layer snapshot and returns canvas log. */ snapshotCommandLog(params: Protocol.LayerTree.SnapshotCommandLogRequest): Promise; on(event: 'layerPainted', listener: (params: Protocol.LayerTree.LayerPaintedEvent) => void): void; on(event: 'layerTreeDidChange', listener: (params: Protocol.LayerTree.LayerTreeDidChangeEvent) => void): void; } export interface LogApi { /** * Clears the log. */ clear(): Promise; /** * Disables log domain, prevents further log entries from being reported to the client. */ disable(): Promise; /** * Enables log domain, sends the entries collected so far to the client by means of the * `entryAdded` notification. */ enable(): Promise; /** * start violation reporting. */ startViolationsReport(params: Protocol.Log.StartViolationsReportRequest): Promise; /** * Stop violation reporting. */ stopViolationsReport(): Promise; /** * Issued when new message was logged. */ on(event: 'entryAdded', listener: (params: Protocol.Log.EntryAddedEvent) => void): void; } export interface MediaApi { /** * Enables the Media domain */ enable(): Promise; /** * Disables the Media domain. */ disable(): Promise; /** * This can be called multiple times, and can be used to set / override / * remove player properties. A null propValue indicates removal. */ on(event: 'playerPropertiesChanged', listener: (params: Protocol.Media.PlayerPropertiesChangedEvent) => void): void; /** * 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. */ on(event: 'playerEventsAdded', listener: (params: Protocol.Media.PlayerEventsAddedEvent) => void): void; /** * Send a list of any messages that need to be delivered. */ on(event: 'playerMessagesLogged', listener: (params: Protocol.Media.PlayerMessagesLoggedEvent) => void): void; /** * Send a list of any errors that need to be delivered. */ on(event: 'playerErrorsRaised', listener: (params: Protocol.Media.PlayerErrorsRaisedEvent) => void): void; /** * 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. */ on(event: 'playerCreated', listener: (params: Protocol.Media.PlayerCreatedEvent) => void): void; } export interface MemoryApi { /** * Retruns current DOM object counters. */ getDOMCounters(): Promise; /** * Retruns DOM object counters after preparing renderer for leak detection. */ getDOMCountersForLeakDetection(): Promise; /** * Prepares for leak detection by terminating workers, stopping spellcheckers, * dropping non-essential internal caches, running garbage collections, etc. */ prepareForLeakDetection(): Promise; /** * Simulate OomIntervention by purging V8 memory. */ forciblyPurgeJavaScriptMemory(): Promise; /** * Enable/disable suppressing memory pressure notifications in all processes. */ setPressureNotificationsSuppressed(params: Protocol.Memory.SetPressureNotificationsSuppressedRequest): Promise