Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.
TypeScript automationchromechromiume2e-testingelectronend-to-end-testingfirefoxjavascriptplaywrighttesttest-automationtestingtesting-toolswebwebkit
chore: build a client bundle (#34847)
Pavel Feldmand5adeb3cf460
diff --git a/package-lock.json b/package-lock.jsonindex eb0399a9cb..70fcacf837 100644--- a/package-lock.json+++ b/package-lock.json@@ -1576,6 +1576,10 @@"resolved": "packages/playwright-browser-webkit","link": true},+ "node_modules/@playwright/client": {+ "resolved": "packages/playwright-client",+ "link": true+ },"node_modules/@playwright/experimental-ct-core": {"resolved": "packages/playwright-ct-core","link": true@@ -8932,6 +8936,17 @@"node": ">=18"}},+ "packages/playwright-client": {+ "name": "@playwright/client",+ "version": "1.51.0-next",+ "license": "Apache-2.0",+ "dependencies": {+ "playwright-core": "1.51.0-next"+ },+ "engines": {+ "node": ">=18"+ }+ },"packages/playwright-core": {"version": "1.51.0-next","license": "Apache-2.0",diff --git a/packages/playwright-core/src/client/clientBundle.ts b/packages/playwright-client/index.d.tssimilarity index 59%rename from packages/playwright-core/src/client/clientBundle.tsrename to packages/playwright-client/index.d.tsindex 99df031213..74906f0947 100644--- a/packages/playwright-core/src/client/clientBundle.ts+++ b/packages/playwright-client/index.d.ts@@ -1,7 +1,7 @@/*** Copyright (c) Microsoft Corporation.*- * Licensed under the Apache License, Version 2.0 (the 'License");+ * Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at*@@ -14,12 +14,12 @@* limitations under the License.*/-import { Connection } from './connection';-import { setPlatformForSelectors } from './selectors';+import type { Browser } from './types/types';-import type { Platform } from './platform';+export * from './types/types';-export function createConnectionFactory(platform: Platform): () => Connection {- setPlatformForSelectors(platform);- return () => new Connection(platform);-}+export type Options = {+ headless?: boolean;+};++export const connect: (wsEndpoint: string, browserName: string, options: Options) => Promise<Browser>;diff --git a/packages/playwright-client/index.js b/packages/playwright-client/index.jsnew file mode 100644index 0000000000..227eee0fde--- /dev/null+++ b/packages/playwright-client/index.js@@ -0,0 +1,17 @@+/**+ * Copyright (c) Microsoft Corporation.+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */++module.exports = require('./lib/index');diff --git a/packages/playwright-client/index.mjs b/packages/playwright-client/index.mjsnew file mode 100644index 0000000000..0332e50157--- /dev/null+++ b/packages/playwright-client/index.mjs@@ -0,0 +1,17 @@+/**+ * Copyright (c) Microsoft Corporation.+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */++export { connect } from './index.js';diff --git a/packages/playwright-client/package.json b/packages/playwright-client/package.jsonnew file mode 100644index 0000000000..57cfa8375a--- /dev/null+++ b/packages/playwright-client/package.json@@ -0,0 +1,34 @@+{+ "name": "@playwright/client",+ "private": true,+ "version": "1.51.0-next",+ "description": "A thin client for Playwright",+ "repository": {+ "type": "git",+ "url": "git+https://github.com/microsoft/playwright.git"+ },+ "homepage": "https://playwright.dev",+ "engines": {+ "node": ">=18"+ },+ "author": {+ "name": "Microsoft Corporation"+ },+ "license": "Apache-2.0",+ "exports": {+ ".": {+ "types": "./index.d.ts",+ "import": "./index.mjs",+ "require": "./index.js",+ "default": "./index.js"+ },+ "./package.json": "./package.json"+ },+ "scripts": {+ "build": "esbuild ./src/index.ts --outdir=lib --format=cjs --bundle --platform=node --target=ES2019",+ "watch": "esbuild ./src/index.ts --outdir=lib --format=cjs --bundle --platform=node --target=ES2019 --watch"+ },+ "dependencies": {+ "playwright-core": "1.51.0-next"+ }+}diff --git a/packages/playwright-client/src/index.ts b/packages/playwright-client/src/index.tsnew file mode 100644index 0000000000..48762e4e81--- /dev/null+++ b/packages/playwright-client/src/index.ts@@ -0,0 +1,40 @@+/**+ * Copyright (c) Microsoft Corporation.+ *+ * Licensed under the Apache License, Version 2.0 (the 'License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */++import { Connection } from '../../playwright-core/src/client/connection';+import { webPlatform } from './webPlatform';++import type { Browser } from '../../playwright-core/src/client/browser';++export type Options = {+ headless?: boolean;+};++export async function connect(wsEndpoint: string, browserName: string, options: Options): Promise<Browser> {+ const ws = new WebSocket(`${wsEndpoint}?browser=${browserName}&launch-options=${JSON.stringify(options)}`);+ await new Promise((f, r) => {+ ws.addEventListener('open', f);+ ws.addEventListener('error', r);+ });++ const connection = new Connection(webPlatform);+ connection.onmessage = message => ws.send(JSON.stringify(message));+ ws.addEventListener('message', message => connection.dispatch(JSON.parse(message.data)));+ ws.addEventListener('close', () => connection.close());++ const playwright = await connection.initializePlaywright();+ return playwright._preLaunchedBrowser();+}diff --git a/packages/playwright-client/src/webPlatform.ts b/packages/playwright-client/src/webPlatform.tsnew file mode 100644index 0000000000..e7d64817ec--- /dev/null+++ b/packages/playwright-client/src/webPlatform.ts@@ -0,0 +1,48 @@+/* eslint-disable no-console */+/**+ * Copyright (c) Microsoft Corporation.+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */++import { emptyPlatform } from '../../playwright-core/src/client/platform';++import type { Platform } from '../../playwright-core/src/client/platform';++export const webPlatform: Platform = {+ ...emptyPlatform,++ name: 'web',++ boxedStackPrefixes: () => [],++ calculateSha1: async (text: string) => {+ const bytes = new TextEncoder().encode(text);+ const hashBuffer = await window.crypto.subtle.digest('SHA-1', bytes);+ return Array.from(new Uint8Array(hashBuffer), b => b.toString(16).padStart(2, '0')).join('');+ },++ createGuid: () => {+ return Array.from(window.crypto.getRandomValues(new Uint8Array(16)), b => b.toString(16).padStart(2, '0')).join('');+ },++ isLogEnabled(name: 'api' | 'channel') {+ return true;+ },++ log(name: 'api' | 'channel', message: string | Error | object) {+ console.debug(name, message);+ },++ showInternalStackFrames: () => true,+};diff --git a/packages/playwright-client/types/types.d.ts b/packages/playwright-client/types/types.d.tsnew file mode 100644index 0000000000..65907853f4--- /dev/null+++ b/packages/playwright-client/types/types.d.ts@@ -0,0 +1,22974 @@+// This file is generated by /utils/generate_types/index.js+/**+ * Copyright (c) Microsoft Corporation.+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+import { ChildProcess } from 'child_process';+import { Readable } from 'stream';+import { ReadStream } from 'fs';+import { Protocol } from './protocol';+import { Serializable, EvaluationArgument, PageFunction, PageFunctionOn, SmartHandle, ElementHandleForTag, BindingSource } from './structs';++type PageWaitForSelectorOptionsNotHidden = PageWaitForSelectorOptions & {+ state?: 'visible'|'attached';+};+type ElementHandleWaitForSelectorOptionsNotHidden = ElementHandleWaitForSelectorOptions & {+ state?: 'visible'|'attached';+};++/**+ * Page provides methods to interact with a single tab in a [Browser](https://playwright.dev/docs/api/class-browser),+ * or an [extension background page](https://developer.chrome.com/extensions/background_pages) in Chromium. One+ * [Browser](https://playwright.dev/docs/api/class-browser) instance might have multiple+ * [Page](https://playwright.dev/docs/api/class-page) instances.+ *+ * This example creates a page, navigates it to a URL, and then saves a screenshot:+ *+ * ```js+ * const { webkit } = require('playwright'); // Or 'chromium' or 'firefox'.+ *+ * (async () => {+ * const browser = await webkit.launch();+ * const context = await browser.newContext();+ * const page = await context.newPage();+ * await page.goto('https://example.com');+ * await page.screenshot({ path: 'screenshot.png' });+ * await browser.close();+ * })();+ * ```+ *+ * The Page class emits various events (described below) which can be handled using any of Node's native+ * [`EventEmitter`](https://nodejs.org/api/events.html#events_class_eventemitter) methods, such as `on`, `once` or+ * `removeListener`.+ *+ * This example logs a message for a single page `load` event:+ *+ * ```js+ * page.once('load', () => console.log('Page loaded!'));+ * ```+ *+ * To unsubscribe from events use the `removeListener` method:+ *+ * ```js+ * function logRequest(interceptedRequest) {+ * console.log('A request was made:', interceptedRequest.url());+ * }+ * page.on('request', logRequest);+ * // Sometime later...+ * page.removeListener('request', logRequest);+ * ```+ *+ */+export interface Page {+ /**+ * Returns the value of the+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-option-expression) invocation.+ *+ * If the function passed to the+ * [page.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate) returns a [Promise],+ * then [page.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate) would wait for+ * the promise to resolve and return its value.+ *+ * If the function passed to the+ * [page.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate) returns a+ * non-[Serializable] value, then+ * [page.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate) resolves to+ * `undefined`. Playwright also supports transferring some additional values that are not serializable by `JSON`:+ * `-0`, `NaN`, `Infinity`, `-Infinity`.+ *+ * **Usage**+ *+ * Passing argument to [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-option-expression):+ *+ * ```js+ * const result = await page.evaluate(([x, y]) => {+ * return Promise.resolve(x * y);+ * }, [7, 8]);+ * console.log(result); // prints "56"+ * ```+ *+ * A string can also be passed in instead of a function:+ *+ * ```js+ * console.log(await page.evaluate('1 + 2')); // prints "3"+ * const x = 10;+ * console.log(await page.evaluate(`1 + ${x}`)); // prints "11"+ * ```+ *+ * [ElementHandle](https://playwright.dev/docs/api/class-elementhandle) instances can be passed as an argument to the+ * [page.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate):+ *+ * ```js+ * const bodyHandle = await page.evaluate('document.body');+ * const html = await page.evaluate<string, HTMLElement>(([body, suffix]) =>+ * body.innerHTML + suffix, [bodyHandle, 'hello']+ * );+ * await bodyHandle.dispose();+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-option-expression).+ */+ evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg): Promise<R>;+ /**+ * Returns the value of the+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-option-expression) invocation.+ *+ * If the function passed to the+ * [page.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate) returns a [Promise],+ * then [page.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate) would wait for+ * the promise to resolve and return its value.+ *+ * If the function passed to the+ * [page.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate) returns a+ * non-[Serializable] value, then+ * [page.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate) resolves to+ * `undefined`. Playwright also supports transferring some additional values that are not serializable by `JSON`:+ * `-0`, `NaN`, `Infinity`, `-Infinity`.+ *+ * **Usage**+ *+ * Passing argument to [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-option-expression):+ *+ * ```js+ * const result = await page.evaluate(([x, y]) => {+ * return Promise.resolve(x * y);+ * }, [7, 8]);+ * console.log(result); // prints "56"+ * ```+ *+ * A string can also be passed in instead of a function:+ *+ * ```js+ * console.log(await page.evaluate('1 + 2')); // prints "3"+ * const x = 10;+ * console.log(await page.evaluate(`1 + ${x}`)); // prints "11"+ * ```+ *+ * [ElementHandle](https://playwright.dev/docs/api/class-elementhandle) instances can be passed as an argument to the+ * [page.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate):+ *+ * ```js+ * const bodyHandle = await page.evaluate('document.body');+ * const html = await page.evaluate<string, HTMLElement>(([body, suffix]) =>+ * body.innerHTML + suffix, [bodyHandle, 'hello']+ * );+ * await bodyHandle.dispose();+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-option-expression).+ */+ evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any): Promise<R>;++ /**+ * Returns the value of the+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-handle-option-expression) invocation as a+ * [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * The only difference between+ * [page.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate) and+ * [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle) is that+ * [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle) returns+ * [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * If the function passed to the+ * [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle) returns+ * a [Promise], then+ * [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle) would+ * wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * // Handle for the window object.+ * const aWindowHandle = await page.evaluateHandle(() => Promise.resolve(window));+ * ```+ *+ * A string can also be passed in instead of a function:+ *+ * ```js+ * const aHandle = await page.evaluateHandle('document'); // Handle for the 'document'+ * ```+ *+ * [JSHandle](https://playwright.dev/docs/api/class-jshandle) instances can be passed as an argument to the+ * [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle):+ *+ * ```js+ * const aHandle = await page.evaluateHandle(() => document.body);+ * const resultHandle = await page.evaluateHandle(body => body.innerHTML, aHandle);+ * console.log(await resultHandle.jsonValue());+ * await resultHandle.dispose();+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-handle-option-expression).+ */+ evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg): Promise<SmartHandle<R>>;+ /**+ * Returns the value of the+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-handle-option-expression) invocation as a+ * [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * The only difference between+ * [page.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate) and+ * [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle) is that+ * [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle) returns+ * [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * If the function passed to the+ * [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle) returns+ * a [Promise], then+ * [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle) would+ * wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * // Handle for the window object.+ * const aWindowHandle = await page.evaluateHandle(() => Promise.resolve(window));+ * ```+ *+ * A string can also be passed in instead of a function:+ *+ * ```js+ * const aHandle = await page.evaluateHandle('document'); // Handle for the 'document'+ * ```+ *+ * [JSHandle](https://playwright.dev/docs/api/class-jshandle) instances can be passed as an argument to the+ * [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle):+ *+ * ```js+ * const aHandle = await page.evaluateHandle(() => document.body);+ * const resultHandle = await page.evaluateHandle(body => body.innerHTML, aHandle);+ * console.log(await resultHandle.jsonValue());+ * await resultHandle.dispose();+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-handle-option-expression).+ */+ evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any): Promise<SmartHandle<R>>;++ /**+ * Adds a script which would be evaluated in one of the following scenarios:+ * - Whenever the page is navigated.+ * - Whenever the child frame is attached or navigated. In this case, the script is evaluated in the context of the+ * newly attached frame.+ *+ * The script is evaluated after the document was created but before any of its scripts were run. This is useful to+ * amend the JavaScript environment, e.g. to seed `Math.random`.+ *+ * **Usage**+ *+ * An example of overriding `Math.random` before the page loads:+ *+ * ```js+ * // preload.js+ * Math.random = () => 42;+ * ```+ *+ * ```js+ * // In your playwright script, assuming the preload.js file is in same directory+ * await page.addInitScript({ path: './preload.js' });+ * ```+ *+ * ```js+ * await page.addInitScript(mock => {+ * window.mock = mock;+ * }, mock);+ * ```+ *+ * **NOTE** The order of evaluation of multiple scripts installed via+ * [browserContext.addInitScript(script[, arg])](https://playwright.dev/docs/api/class-browsercontext#browser-context-add-init-script)+ * and [page.addInitScript(script[, arg])](https://playwright.dev/docs/api/class-page#page-add-init-script) is not+ * defined.+ *+ * @param script Script to be evaluated in the page.+ * @param arg Optional argument to pass to+ * [`script`](https://playwright.dev/docs/api/class-page#page-add-init-script-option-script) (only supported when+ * passing a function).+ */+ addInitScript<Arg>(script: PageFunction<Arg, any> | { path?: string, content?: string }, arg?: Arg): Promise<void>;++ /**+ * **NOTE** Use locator-based [page.locator(selector[, options])](https://playwright.dev/docs/api/class-page#page-locator)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * The method finds an element matching the specified selector within the page. If no elements match the selector, the+ * return value resolves to `null`. To wait for an element on the page, use+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for).+ * @param selector A selector to query for.+ * @param options+ */+ $<K extends keyof HTMLElementTagNameMap>(selector: K, options?: { strict: boolean }): Promise<ElementHandleForTag<K> | null>;+ /**+ * **NOTE** Use locator-based [page.locator(selector[, options])](https://playwright.dev/docs/api/class-page#page-locator)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * The method finds an element matching the specified selector within the page. If no elements match the selector, the+ * return value resolves to `null`. To wait for an element on the page, use+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for).+ * @param selector A selector to query for.+ * @param options+ */+ $(selector: string, options?: { strict: boolean }): Promise<ElementHandle<SVGElement | HTMLElement> | null>;++ /**+ * **NOTE** Use locator-based [page.locator(selector[, options])](https://playwright.dev/docs/api/class-page#page-locator)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * The method finds all elements matching the specified selector within the page. If no elements match the selector,+ * the return value resolves to `[]`.+ * @param selector A selector to query for.+ */+ $$<K extends keyof HTMLElementTagNameMap>(selector: K): Promise<ElementHandleForTag<K>[]>;+ /**+ * **NOTE** Use locator-based [page.locator(selector[, options])](https://playwright.dev/docs/api/class-page#page-locator)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * The method finds all elements matching the specified selector within the page. If no elements match the selector,+ * the return value resolves to `[]`.+ * @param selector A selector to query for.+ */+ $$(selector: string): Promise<ElementHandle<SVGElement | HTMLElement>[]>;++ /**+ * **NOTE** This method does not wait for the element to pass actionability checks and therefore can lead to the flaky tests.+ * Use+ * [locator.evaluate(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods or web-first assertions instead.+ *+ * The method finds an element matching the specified selector within the page and passes it as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression). If no+ * elements match the selector, the method throws an error. Returns the value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression).+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression) returns a+ * [Promise], then+ * [page.$eval(selector, pageFunction[, arg, options])](https://playwright.dev/docs/api/class-page#page-eval-on-selector)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const searchValue = await page.$eval('#search', el => el.value);+ * const preloadHref = await page.$eval('link[rel=preload]', el => el.href);+ * const html = await page.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');+ * // In TypeScript, this example requires an explicit type annotation (HTMLLinkElement) on el:+ * const preloadHrefTS = await page.$eval('link[rel=preload]', (el: HTMLLinkElement) => el.href);+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression).+ * @param options+ */+ $eval<K extends keyof HTMLElementTagNameMap, R, Arg>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K], Arg, R>, arg: Arg): Promise<R>;+ /**+ * **NOTE** This method does not wait for the element to pass actionability checks and therefore can lead to the flaky tests.+ * Use+ * [locator.evaluate(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods or web-first assertions instead.+ *+ * The method finds an element matching the specified selector within the page and passes it as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression). If no+ * elements match the selector, the method throws an error. Returns the value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression).+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression) returns a+ * [Promise], then+ * [page.$eval(selector, pageFunction[, arg, options])](https://playwright.dev/docs/api/class-page#page-eval-on-selector)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const searchValue = await page.$eval('#search', el => el.value);+ * const preloadHref = await page.$eval('link[rel=preload]', el => el.href);+ * const html = await page.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');+ * // In TypeScript, this example requires an explicit type annotation (HTMLLinkElement) on el:+ * const preloadHrefTS = await page.$eval('link[rel=preload]', (el: HTMLLinkElement) => el.href);+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression).+ * @param options+ */+ $eval<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E, Arg, R>, arg: Arg): Promise<R>;+ /**+ * **NOTE** This method does not wait for the element to pass actionability checks and therefore can lead to the flaky tests.+ * Use+ * [locator.evaluate(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods or web-first assertions instead.+ *+ * The method finds an element matching the specified selector within the page and passes it as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression). If no+ * elements match the selector, the method throws an error. Returns the value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression).+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression) returns a+ * [Promise], then+ * [page.$eval(selector, pageFunction[, arg, options])](https://playwright.dev/docs/api/class-page#page-eval-on-selector)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const searchValue = await page.$eval('#search', el => el.value);+ * const preloadHref = await page.$eval('link[rel=preload]', el => el.href);+ * const html = await page.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');+ * // In TypeScript, this example requires an explicit type annotation (HTMLLinkElement) on el:+ * const preloadHrefTS = await page.$eval('link[rel=preload]', (el: HTMLLinkElement) => el.href);+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression).+ * @param options+ */+ $eval<K extends keyof HTMLElementTagNameMap, R>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K], void, R>, arg?: any): Promise<R>;+ /**+ * **NOTE** This method does not wait for the element to pass actionability checks and therefore can lead to the flaky tests.+ * Use+ * [locator.evaluate(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods or web-first assertions instead.+ *+ * The method finds an element matching the specified selector within the page and passes it as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression). If no+ * elements match the selector, the method throws an error. Returns the value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression).+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression) returns a+ * [Promise], then+ * [page.$eval(selector, pageFunction[, arg, options])](https://playwright.dev/docs/api/class-page#page-eval-on-selector)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const searchValue = await page.$eval('#search', el => el.value);+ * const preloadHref = await page.$eval('link[rel=preload]', el => el.href);+ * const html = await page.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');+ * // In TypeScript, this example requires an explicit type annotation (HTMLLinkElement) on el:+ * const preloadHrefTS = await page.$eval('link[rel=preload]', (el: HTMLLinkElement) => el.href);+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-option-expression).+ * @param options+ */+ $eval<R, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E, void, R>, arg?: any): Promise<R>;++ /**+ * **NOTE** In most cases,+ * [locator.evaluateAll(pageFunction[, arg])](https://playwright.dev/docs/api/class-locator#locator-evaluate-all),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods and web-first assertions do a better+ * job.+ *+ * The method finds all elements matching the specified selector within the page and passes an array of matched+ * elements as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression). Returns+ * the result of+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression)+ * invocation.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression) returns+ * a [Promise], then+ * [page.$$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const divCounts = await page.$$eval('div', (divs, min) => divs.length >= min, 10);+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression).+ */+ $$eval<K extends keyof HTMLElementTagNameMap, R, Arg>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K][], Arg, R>, arg: Arg): Promise<R>;+ /**+ * **NOTE** In most cases,+ * [locator.evaluateAll(pageFunction[, arg])](https://playwright.dev/docs/api/class-locator#locator-evaluate-all),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods and web-first assertions do a better+ * job.+ *+ * The method finds all elements matching the specified selector within the page and passes an array of matched+ * elements as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression). Returns+ * the result of+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression)+ * invocation.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression) returns+ * a [Promise], then+ * [page.$$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const divCounts = await page.$$eval('div', (divs, min) => divs.length >= min, 10);+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression).+ */+ $$eval<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E[], Arg, R>, arg: Arg): Promise<R>;+ /**+ * **NOTE** In most cases,+ * [locator.evaluateAll(pageFunction[, arg])](https://playwright.dev/docs/api/class-locator#locator-evaluate-all),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods and web-first assertions do a better+ * job.+ *+ * The method finds all elements matching the specified selector within the page and passes an array of matched+ * elements as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression). Returns+ * the result of+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression)+ * invocation.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression) returns+ * a [Promise], then+ * [page.$$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const divCounts = await page.$$eval('div', (divs, min) => divs.length >= min, 10);+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression).+ */+ $$eval<K extends keyof HTMLElementTagNameMap, R>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K][], void, R>, arg?: any): Promise<R>;+ /**+ * **NOTE** In most cases,+ * [locator.evaluateAll(pageFunction[, arg])](https://playwright.dev/docs/api/class-locator#locator-evaluate-all),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods and web-first assertions do a better+ * job.+ *+ * The method finds all elements matching the specified selector within the page and passes an array of matched+ * elements as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression). Returns+ * the result of+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression)+ * invocation.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression) returns+ * a [Promise], then+ * [page.$$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const divCounts = await page.$$eval('div', (divs, min) => divs.length >= min, 10);+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-eval-on-selector-all-option-expression).+ */+ $$eval<R, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E[], void, R>, arg?: any): Promise<R>;++ /**+ * Returns when the+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-wait-for-function-option-expression) returns a+ * truthy value. It resolves to a JSHandle of the truthy value.+ *+ * **Usage**+ *+ * The+ * [page.waitForFunction(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-page#page-wait-for-function)+ * can be used to observe viewport size change:+ *+ * ```js+ * const { webkit } = require('playwright'); // Or 'chromium' or 'firefox'.+ *+ * (async () => {+ * const browser = await webkit.launch();+ * const page = await browser.newPage();+ * const watchDog = page.waitForFunction(() => window.innerWidth < 100);+ * await page.setViewportSize({ width: 50, height: 50 });+ * await watchDog;+ * await browser.close();+ * })();+ * ```+ *+ * To pass an argument to the predicate of+ * [page.waitForFunction(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-page#page-wait-for-function)+ * function:+ *+ * ```js+ * const selector = '.foo';+ * await page.waitForFunction(selector => !!document.querySelector(selector), selector);+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-wait-for-function-option-expression).+ * @param options+ */+ waitForFunction<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: PageWaitForFunctionOptions): Promise<SmartHandle<R>>;+ /**+ * Returns when the+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-wait-for-function-option-expression) returns a+ * truthy value. It resolves to a JSHandle of the truthy value.+ *+ * **Usage**+ *+ * The+ * [page.waitForFunction(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-page#page-wait-for-function)+ * can be used to observe viewport size change:+ *+ * ```js+ * const { webkit } = require('playwright'); // Or 'chromium' or 'firefox'.+ *+ * (async () => {+ * const browser = await webkit.launch();+ * const page = await browser.newPage();+ * const watchDog = page.waitForFunction(() => window.innerWidth < 100);+ * await page.setViewportSize({ width: 50, height: 50 });+ * await watchDog;+ * await browser.close();+ * })();+ * ```+ *+ * To pass an argument to the predicate of+ * [page.waitForFunction(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-page#page-wait-for-function)+ * function:+ *+ * ```js+ * const selector = '.foo';+ * await page.waitForFunction(selector => !!document.querySelector(selector), selector);+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-wait-for-function-option-expression).+ * @param options+ */+ waitForFunction<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: PageWaitForFunctionOptions): Promise<SmartHandle<R>>;++ /**+ * **NOTE** Use web assertions that assert visibility or a locator-based+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for) instead. Read more+ * about [locators](https://playwright.dev/docs/locators).+ *+ * Returns when element specified by selector satisfies+ * [`state`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-state) option. Returns `null` if+ * waiting for `hidden` or `detached`.+ *+ * **NOTE** Playwright automatically waits for element to be ready before performing an action. Using+ * [Locator](https://playwright.dev/docs/api/class-locator) objects and web-first assertions makes the code+ * wait-for-selector-free.+ *+ * Wait for the [`selector`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-selector) to+ * satisfy [`state`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-state) option (either+ * appear/disappear from dom, or become visible/hidden). If at the moment of calling the method+ * [`selector`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-selector) already satisfies+ * the condition, the method will return immediately. If the selector doesn't satisfy the condition for the+ * [`timeout`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-timeout) milliseconds, the+ * function will throw.+ *+ * **Usage**+ *+ * This method works across navigations:+ *+ * ```js+ * const { chromium } = require('playwright'); // Or 'firefox' or 'webkit'.+ *+ * (async () => {+ * const browser = await chromium.launch();+ * const page = await browser.newPage();+ * for (const currentURL of ['https://google.com', 'https://bbc.com']) {+ * await page.goto(currentURL);+ * const element = await page.waitForSelector('img');+ * console.log('Loaded image: ' + await element.getAttribute('src'));+ * }+ * await browser.close();+ * })();+ * ```+ *+ * @param selector A selector to query for.+ * @param options+ */+ waitForSelector<K extends keyof HTMLElementTagNameMap>(selector: K, options?: PageWaitForSelectorOptionsNotHidden): Promise<ElementHandleForTag<K>>;+ /**+ * **NOTE** Use web assertions that assert visibility or a locator-based+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for) instead. Read more+ * about [locators](https://playwright.dev/docs/locators).+ *+ * Returns when element specified by selector satisfies+ * [`state`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-state) option. Returns `null` if+ * waiting for `hidden` or `detached`.+ *+ * **NOTE** Playwright automatically waits for element to be ready before performing an action. Using+ * [Locator](https://playwright.dev/docs/api/class-locator) objects and web-first assertions makes the code+ * wait-for-selector-free.+ *+ * Wait for the [`selector`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-selector) to+ * satisfy [`state`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-state) option (either+ * appear/disappear from dom, or become visible/hidden). If at the moment of calling the method+ * [`selector`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-selector) already satisfies+ * the condition, the method will return immediately. If the selector doesn't satisfy the condition for the+ * [`timeout`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-timeout) milliseconds, the+ * function will throw.+ *+ * **Usage**+ *+ * This method works across navigations:+ *+ * ```js+ * const { chromium } = require('playwright'); // Or 'firefox' or 'webkit'.+ *+ * (async () => {+ * const browser = await chromium.launch();+ * const page = await browser.newPage();+ * for (const currentURL of ['https://google.com', 'https://bbc.com']) {+ * await page.goto(currentURL);+ * const element = await page.waitForSelector('img');+ * console.log('Loaded image: ' + await element.getAttribute('src'));+ * }+ * await browser.close();+ * })();+ * ```+ *+ * @param selector A selector to query for.+ * @param options+ */+ waitForSelector(selector: string, options?: PageWaitForSelectorOptionsNotHidden): Promise<ElementHandle<SVGElement | HTMLElement>>;+ /**+ * **NOTE** Use web assertions that assert visibility or a locator-based+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for) instead. Read more+ * about [locators](https://playwright.dev/docs/locators).+ *+ * Returns when element specified by selector satisfies+ * [`state`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-state) option. Returns `null` if+ * waiting for `hidden` or `detached`.+ *+ * **NOTE** Playwright automatically waits for element to be ready before performing an action. Using+ * [Locator](https://playwright.dev/docs/api/class-locator) objects and web-first assertions makes the code+ * wait-for-selector-free.+ *+ * Wait for the [`selector`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-selector) to+ * satisfy [`state`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-state) option (either+ * appear/disappear from dom, or become visible/hidden). If at the moment of calling the method+ * [`selector`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-selector) already satisfies+ * the condition, the method will return immediately. If the selector doesn't satisfy the condition for the+ * [`timeout`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-timeout) milliseconds, the+ * function will throw.+ *+ * **Usage**+ *+ * This method works across navigations:+ *+ * ```js+ * const { chromium } = require('playwright'); // Or 'firefox' or 'webkit'.+ *+ * (async () => {+ * const browser = await chromium.launch();+ * const page = await browser.newPage();+ * for (const currentURL of ['https://google.com', 'https://bbc.com']) {+ * await page.goto(currentURL);+ * const element = await page.waitForSelector('img');+ * console.log('Loaded image: ' + await element.getAttribute('src'));+ * }+ * await browser.close();+ * })();+ * ```+ *+ * @param selector A selector to query for.+ * @param options+ */+ waitForSelector<K extends keyof HTMLElementTagNameMap>(selector: K, options: PageWaitForSelectorOptions): Promise<ElementHandleForTag<K> | null>;+ /**+ * **NOTE** Use web assertions that assert visibility or a locator-based+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for) instead. Read more+ * about [locators](https://playwright.dev/docs/locators).+ *+ * Returns when element specified by selector satisfies+ * [`state`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-state) option. Returns `null` if+ * waiting for `hidden` or `detached`.+ *+ * **NOTE** Playwright automatically waits for element to be ready before performing an action. Using+ * [Locator](https://playwright.dev/docs/api/class-locator) objects and web-first assertions makes the code+ * wait-for-selector-free.+ *+ * Wait for the [`selector`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-selector) to+ * satisfy [`state`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-state) option (either+ * appear/disappear from dom, or become visible/hidden). If at the moment of calling the method+ * [`selector`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-selector) already satisfies+ * the condition, the method will return immediately. If the selector doesn't satisfy the condition for the+ * [`timeout`](https://playwright.dev/docs/api/class-page#page-wait-for-selector-option-timeout) milliseconds, the+ * function will throw.+ *+ * **Usage**+ *+ * This method works across navigations:+ *+ * ```js+ * const { chromium } = require('playwright'); // Or 'firefox' or 'webkit'.+ *+ * (async () => {+ * const browser = await chromium.launch();+ * const page = await browser.newPage();+ * for (const currentURL of ['https://google.com', 'https://bbc.com']) {+ * await page.goto(currentURL);+ * const element = await page.waitForSelector('img');+ * console.log('Loaded image: ' + await element.getAttribute('src'));+ * }+ * await browser.close();+ * })();+ * ```+ *+ * @param selector A selector to query for.+ * @param options+ */+ waitForSelector(selector: string, options: PageWaitForSelectorOptions): Promise<null|ElementHandle<SVGElement | HTMLElement>>;++ /**+ * The method adds a function called+ * [`name`](https://playwright.dev/docs/api/class-page#page-expose-binding-option-name) on the `window` object of+ * every frame in this page. When called, the function executes+ * [`callback`](https://playwright.dev/docs/api/class-page#page-expose-binding-option-callback) and returns a+ * [Promise] which resolves to the return value of+ * [`callback`](https://playwright.dev/docs/api/class-page#page-expose-binding-option-callback). If the+ * [`callback`](https://playwright.dev/docs/api/class-page#page-expose-binding-option-callback) returns a [Promise],+ * it will be awaited.+ *+ * The first argument of the+ * [`callback`](https://playwright.dev/docs/api/class-page#page-expose-binding-option-callback) function contains+ * information about the caller: `{ browserContext: BrowserContext, page: Page, frame: Frame }`.+ *+ * See+ * [browserContext.exposeBinding(name, callback[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-binding)+ * for the context-wide version.+ *+ * **NOTE** Functions installed via+ * [page.exposeBinding(name, callback[, options])](https://playwright.dev/docs/api/class-page#page-expose-binding)+ * survive navigations.+ *+ * **Usage**+ *+ * An example of exposing page URL to all frames in a page:+ *+ * ```js+ * const { webkit } = require('playwright'); // Or 'chromium' or 'firefox'.+ *+ * (async () => {+ * const browser = await webkit.launch({ headless: false });+ * const context = await browser.newContext();+ * const page = await context.newPage();+ * await page.exposeBinding('pageURL', ({ page }) => page.url());+ * await page.setContent(`+ * <script>+ * async function onClick() {+ * document.querySelector('div').textContent = await window.pageURL();+ * }+ * </script>+ * <button onclick="onClick()">Click me</button>+ * <div></div>+ * `);+ * await page.click('button');+ * })();+ * ```+ *+ * @param name Name of the function on the window object.+ * @param callback Callback function that will be called in the Playwright's context.+ * @param options+ */+ exposeBinding(name: string, playwrightBinding: (source: BindingSource, arg: JSHandle) => any, options: { handle: true }): Promise<void>;+ /**+ * The method adds a function called+ * [`name`](https://playwright.dev/docs/api/class-page#page-expose-binding-option-name) on the `window` object of+ * every frame in this page. When called, the function executes+ * [`callback`](https://playwright.dev/docs/api/class-page#page-expose-binding-option-callback) and returns a+ * [Promise] which resolves to the return value of+ * [`callback`](https://playwright.dev/docs/api/class-page#page-expose-binding-option-callback). If the+ * [`callback`](https://playwright.dev/docs/api/class-page#page-expose-binding-option-callback) returns a [Promise],+ * it will be awaited.+ *+ * The first argument of the+ * [`callback`](https://playwright.dev/docs/api/class-page#page-expose-binding-option-callback) function contains+ * information about the caller: `{ browserContext: BrowserContext, page: Page, frame: Frame }`.+ *+ * See+ * [browserContext.exposeBinding(name, callback[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-binding)+ * for the context-wide version.+ *+ * **NOTE** Functions installed via+ * [page.exposeBinding(name, callback[, options])](https://playwright.dev/docs/api/class-page#page-expose-binding)+ * survive navigations.+ *+ * **Usage**+ *+ * An example of exposing page URL to all frames in a page:+ *+ * ```js+ * const { webkit } = require('playwright'); // Or 'chromium' or 'firefox'.+ *+ * (async () => {+ * const browser = await webkit.launch({ headless: false });+ * const context = await browser.newContext();+ * const page = await context.newPage();+ * await page.exposeBinding('pageURL', ({ page }) => page.url());+ * await page.setContent(`+ * <script>+ * async function onClick() {+ * document.querySelector('div').textContent = await window.pageURL();+ * }+ * </script>+ * <button onclick="onClick()">Click me</button>+ * <div></div>+ * `);+ * await page.click('button');+ * })();+ * ```+ *+ * @param name Name of the function on the window object.+ * @param callback Callback function that will be called in the Playwright's context.+ * @param options+ */+ exposeBinding(name: string, playwrightBinding: (source: BindingSource, ...args: any[]) => any, options?: { handle?: boolean }): Promise<void>;++ /**+ * Removes all the listeners of the given type (or all registered listeners if no type given). Allows to wait for+ * async listeners to complete or to ignore subsequent errors from these listeners.+ *+ * **Usage**+ *+ * ```js+ * page.on('request', async request => {+ * const response = await request.response();+ * const body = await response.body();+ * console.log(body.byteLength);+ * });+ * await page.goto('https://playwright.dev', { waitUntil: 'domcontentloaded' });+ * // Waits for all the reported 'request' events to resolve.+ * await page.removeAllListeners('request', { behavior: 'wait' });+ * ```+ *+ * @param type+ * @param options+ */+ removeAllListeners(type?: string): this;+ /**+ * Removes all the listeners of the given type (or all registered listeners if no type given). Allows to wait for+ * async listeners to complete or to ignore subsequent errors from these listeners.+ *+ * **Usage**+ *+ * ```js+ * page.on('request', async request => {+ * const response = await request.response();+ * const body = await response.body();+ * console.log(body.byteLength);+ * });+ * await page.goto('https://playwright.dev', { waitUntil: 'domcontentloaded' });+ * // Waits for all the reported 'request' events to resolve.+ * await page.removeAllListeners('request', { behavior: 'wait' });+ * ```+ *+ * @param type+ * @param options+ */+ removeAllListeners(type: string | undefined, options: {+ /**+ * Specifies whether to wait for already running listeners and what to do if they throw errors:+ * - `'default'` - do not wait for current listener calls (if any) to finish, if the listener throws, it may result in unhandled error+ * - `'wait'` - wait for current listener calls (if any) to finish+ * - `'ignoreErrors'` - do not wait for current listener calls (if any) to finish, all errors thrown by the listeners after removal are silently caught+ */+ behavior?: 'wait'|'ignoreErrors'|'default'+ }): Promise<void>;+ /**+ * Emitted when the page closes.+ */+ on(event: 'close', listener: (page: Page) => any): this;++ /**+ * Emitted when JavaScript within the page calls one of console API methods, e.g. `console.log` or `console.dir`.+ *+ * The arguments passed into `console.log` are available on the+ * [ConsoleMessage](https://playwright.dev/docs/api/class-consolemessage) event handler argument.+ *+ * **Usage**+ *+ * ```js+ * page.on('console', async msg => {+ * const values = [];+ * for (const arg of msg.args())+ * values.push(await arg.jsonValue());+ * console.log(...values);+ * });+ * await page.evaluate(() => console.log('hello', 5, { foo: 'bar' }));+ * ```+ *+ */+ on(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Emitted when the page crashes. Browser pages might crash if they try to allocate too much memory. When the page+ * crashes, ongoing and subsequent operations will throw.+ *+ * The most common way to deal with crashes is to catch an exception:+ *+ * ```js+ * try {+ * // Crash might happen during a click.+ * await page.click('button');+ * // Or while waiting for an event.+ * await page.waitForEvent('popup');+ * } catch (e) {+ * // When the page crashes, exception message contains 'crash'.+ * }+ * ```+ *+ */+ on(event: 'crash', listener: (page: Page) => any): this;++ /**+ * Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**+ * either [dialog.accept([promptText])](https://playwright.dev/docs/api/class-dialog#dialog-accept) or+ * [dialog.dismiss()](https://playwright.dev/docs/api/class-dialog#dialog-dismiss) the dialog - otherwise the page+ * will [freeze](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#never_blocking) waiting for the+ * dialog, and actions like click will never finish.+ *+ * **Usage**+ *+ * ```js+ * page.on('dialog', dialog => dialog.accept());+ * ```+ *+ * **NOTE** When no [page.on('dialog')](https://playwright.dev/docs/api/class-page#page-event-dialog) or+ * [browserContext.on('dialog')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-dialog)+ * listeners are present, all dialogs are automatically dismissed.+ *+ */+ on(event: 'dialog', listener: (dialog: Dialog) => any): this;++ /**+ * Emitted when the JavaScript+ * [`DOMContentLoaded`](https://developer.mozilla.org/en-US/docs/Web/Events/DOMContentLoaded) event is dispatched.+ */+ on(event: 'domcontentloaded', listener: (page: Page) => any): this;++ /**+ * Emitted when attachment download started. User can access basic file operations on downloaded content via the+ * passed [Download](https://playwright.dev/docs/api/class-download) instance.+ */+ on(event: 'download', listener: (download: Download) => any): this;++ /**+ * Emitted when a file chooser is supposed to appear, such as after clicking the `<input type=file>`. Playwright can+ * respond to it via setting the input files using+ * [fileChooser.setFiles(files[, options])](https://playwright.dev/docs/api/class-filechooser#file-chooser-set-files)+ * that can be uploaded after that.+ *+ * ```js+ * page.on('filechooser', async fileChooser => {+ * await fileChooser.setFiles(path.join(__dirname, '/tmp/myfile.pdf'));+ * });+ * ```+ *+ */+ on(event: 'filechooser', listener: (fileChooser: FileChooser) => any): this;++ /**+ * Emitted when a frame is attached.+ */+ on(event: 'frameattached', listener: (frame: Frame) => any): this;++ /**+ * Emitted when a frame is detached.+ */+ on(event: 'framedetached', listener: (frame: Frame) => any): this;++ /**+ * Emitted when a frame is navigated to a new url.+ */+ on(event: 'framenavigated', listener: (frame: Frame) => any): this;++ /**+ * Emitted when the JavaScript [`load`](https://developer.mozilla.org/en-US/docs/Web/Events/load) event is dispatched.+ */+ on(event: 'load', listener: (page: Page) => any): this;++ /**+ * Emitted when an uncaught exception happens within the page.+ *+ * ```js+ * // Log all uncaught errors to the terminal+ * page.on('pageerror', exception => {+ * console.log(`Uncaught exception: "${exception}"`);+ * });+ *+ * // Navigate to a page with an exception.+ * await page.goto('data:text/html,<script>throw new Error("Test")</script>');+ * ```+ *+ */+ on(event: 'pageerror', listener: (error: Error) => any): this;++ /**+ * Emitted when the page opens a new tab or window. This event is emitted in addition to the+ * [browserContext.on('page')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-page), but+ * only for popups relevant to this page.+ *+ * The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a+ * popup with `window.open('http://example.com')`, this event will fire when the network request to+ * "http://example.com" is done and its response has started loading in the popup. If you would like to route/listen+ * to this network request, use+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * and+ * [browserContext.on('request')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request)+ * respectively instead of similar methods on the [Page](https://playwright.dev/docs/api/class-page).+ *+ * ```js+ * // Start waiting for popup before clicking. Note no await.+ * const popupPromise = page.waitForEvent('popup');+ * await page.getByText('open the popup').click();+ * const popup = await popupPromise;+ * console.log(await popup.evaluate('location.href'));+ * ```+ *+ * **NOTE** Use+ * [page.waitForLoadState([state, options])](https://playwright.dev/docs/api/class-page#page-wait-for-load-state) to+ * wait until the page gets to a particular state (you should not need it in most cases).+ *+ */+ on(event: 'popup', listener: (page: Page) => any): this;++ /**+ * Emitted when a page issues a request. The [request] object is read-only. In order to intercept and mutate requests,+ * see [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route) or+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route).+ */+ on(event: 'request', listener: (request: Request) => any): this;++ /**+ * Emitted when a request fails, for example by timing out.+ *+ * ```js+ * page.on('requestfailed', request => {+ * console.log(request.url() + ' ' + request.failure().errorText);+ * });+ * ```+ *+ * **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request+ * will complete with+ * [page.on('requestfinished')](https://playwright.dev/docs/api/class-page#page-event-request-finished) event and not+ * with [page.on('requestfailed')](https://playwright.dev/docs/api/class-page#page-event-request-failed). A request+ * will only be considered failed when the client cannot get an HTTP response from the server, e.g. due to network+ * error net::ERR_FAILED.+ *+ */+ on(event: 'requestfailed', listener: (request: Request) => any): this;++ /**+ * Emitted when a request finishes successfully after downloading the response body. For a successful response, the+ * sequence of events is `request`, `response` and `requestfinished`.+ */+ on(event: 'requestfinished', listener: (request: Request) => any): this;++ /**+ * Emitted when [response] status and headers are received for a request. For a successful response, the sequence of+ * events is `request`, `response` and `requestfinished`.+ */+ on(event: 'response', listener: (response: Response) => any): this;++ /**+ * Emitted when [WebSocket](https://playwright.dev/docs/api/class-websocket) request is sent.+ */+ on(event: 'websocket', listener: (webSocket: WebSocket) => any): this;++ /**+ * Emitted when a dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is spawned+ * by the page.+ */+ on(event: 'worker', listener: (worker: Worker) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'close', listener: (page: Page) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'crash', listener: (page: Page) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'dialog', listener: (dialog: Dialog) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'domcontentloaded', listener: (page: Page) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'download', listener: (download: Download) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'filechooser', listener: (fileChooser: FileChooser) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'frameattached', listener: (frame: Frame) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'framedetached', listener: (frame: Frame) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'framenavigated', listener: (frame: Frame) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'load', listener: (page: Page) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'pageerror', listener: (error: Error) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'popup', listener: (page: Page) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'request', listener: (request: Request) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'requestfailed', listener: (request: Request) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'requestfinished', listener: (request: Request) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'response', listener: (response: Response) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'websocket', listener: (webSocket: WebSocket) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'worker', listener: (worker: Worker) => any): this;++ /**+ * Emitted when the page closes.+ */+ addListener(event: 'close', listener: (page: Page) => any): this;++ /**+ * Emitted when JavaScript within the page calls one of console API methods, e.g. `console.log` or `console.dir`.+ *+ * The arguments passed into `console.log` are available on the+ * [ConsoleMessage](https://playwright.dev/docs/api/class-consolemessage) event handler argument.+ *+ * **Usage**+ *+ * ```js+ * page.on('console', async msg => {+ * const values = [];+ * for (const arg of msg.args())+ * values.push(await arg.jsonValue());+ * console.log(...values);+ * });+ * await page.evaluate(() => console.log('hello', 5, { foo: 'bar' }));+ * ```+ *+ */+ addListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Emitted when the page crashes. Browser pages might crash if they try to allocate too much memory. When the page+ * crashes, ongoing and subsequent operations will throw.+ *+ * The most common way to deal with crashes is to catch an exception:+ *+ * ```js+ * try {+ * // Crash might happen during a click.+ * await page.click('button');+ * // Or while waiting for an event.+ * await page.waitForEvent('popup');+ * } catch (e) {+ * // When the page crashes, exception message contains 'crash'.+ * }+ * ```+ *+ */+ addListener(event: 'crash', listener: (page: Page) => any): this;++ /**+ * Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**+ * either [dialog.accept([promptText])](https://playwright.dev/docs/api/class-dialog#dialog-accept) or+ * [dialog.dismiss()](https://playwright.dev/docs/api/class-dialog#dialog-dismiss) the dialog - otherwise the page+ * will [freeze](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#never_blocking) waiting for the+ * dialog, and actions like click will never finish.+ *+ * **Usage**+ *+ * ```js+ * page.on('dialog', dialog => dialog.accept());+ * ```+ *+ * **NOTE** When no [page.on('dialog')](https://playwright.dev/docs/api/class-page#page-event-dialog) or+ * [browserContext.on('dialog')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-dialog)+ * listeners are present, all dialogs are automatically dismissed.+ *+ */+ addListener(event: 'dialog', listener: (dialog: Dialog) => any): this;++ /**+ * Emitted when the JavaScript+ * [`DOMContentLoaded`](https://developer.mozilla.org/en-US/docs/Web/Events/DOMContentLoaded) event is dispatched.+ */+ addListener(event: 'domcontentloaded', listener: (page: Page) => any): this;++ /**+ * Emitted when attachment download started. User can access basic file operations on downloaded content via the+ * passed [Download](https://playwright.dev/docs/api/class-download) instance.+ */+ addListener(event: 'download', listener: (download: Download) => any): this;++ /**+ * Emitted when a file chooser is supposed to appear, such as after clicking the `<input type=file>`. Playwright can+ * respond to it via setting the input files using+ * [fileChooser.setFiles(files[, options])](https://playwright.dev/docs/api/class-filechooser#file-chooser-set-files)+ * that can be uploaded after that.+ *+ * ```js+ * page.on('filechooser', async fileChooser => {+ * await fileChooser.setFiles(path.join(__dirname, '/tmp/myfile.pdf'));+ * });+ * ```+ *+ */+ addListener(event: 'filechooser', listener: (fileChooser: FileChooser) => any): this;++ /**+ * Emitted when a frame is attached.+ */+ addListener(event: 'frameattached', listener: (frame: Frame) => any): this;++ /**+ * Emitted when a frame is detached.+ */+ addListener(event: 'framedetached', listener: (frame: Frame) => any): this;++ /**+ * Emitted when a frame is navigated to a new url.+ */+ addListener(event: 'framenavigated', listener: (frame: Frame) => any): this;++ /**+ * Emitted when the JavaScript [`load`](https://developer.mozilla.org/en-US/docs/Web/Events/load) event is dispatched.+ */+ addListener(event: 'load', listener: (page: Page) => any): this;++ /**+ * Emitted when an uncaught exception happens within the page.+ *+ * ```js+ * // Log all uncaught errors to the terminal+ * page.on('pageerror', exception => {+ * console.log(`Uncaught exception: "${exception}"`);+ * });+ *+ * // Navigate to a page with an exception.+ * await page.goto('data:text/html,<script>throw new Error("Test")</script>');+ * ```+ *+ */+ addListener(event: 'pageerror', listener: (error: Error) => any): this;++ /**+ * Emitted when the page opens a new tab or window. This event is emitted in addition to the+ * [browserContext.on('page')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-page), but+ * only for popups relevant to this page.+ *+ * The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a+ * popup with `window.open('http://example.com')`, this event will fire when the network request to+ * "http://example.com" is done and its response has started loading in the popup. If you would like to route/listen+ * to this network request, use+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * and+ * [browserContext.on('request')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request)+ * respectively instead of similar methods on the [Page](https://playwright.dev/docs/api/class-page).+ *+ * ```js+ * // Start waiting for popup before clicking. Note no await.+ * const popupPromise = page.waitForEvent('popup');+ * await page.getByText('open the popup').click();+ * const popup = await popupPromise;+ * console.log(await popup.evaluate('location.href'));+ * ```+ *+ * **NOTE** Use+ * [page.waitForLoadState([state, options])](https://playwright.dev/docs/api/class-page#page-wait-for-load-state) to+ * wait until the page gets to a particular state (you should not need it in most cases).+ *+ */+ addListener(event: 'popup', listener: (page: Page) => any): this;++ /**+ * Emitted when a page issues a request. The [request] object is read-only. In order to intercept and mutate requests,+ * see [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route) or+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route).+ */+ addListener(event: 'request', listener: (request: Request) => any): this;++ /**+ * Emitted when a request fails, for example by timing out.+ *+ * ```js+ * page.on('requestfailed', request => {+ * console.log(request.url() + ' ' + request.failure().errorText);+ * });+ * ```+ *+ * **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request+ * will complete with+ * [page.on('requestfinished')](https://playwright.dev/docs/api/class-page#page-event-request-finished) event and not+ * with [page.on('requestfailed')](https://playwright.dev/docs/api/class-page#page-event-request-failed). A request+ * will only be considered failed when the client cannot get an HTTP response from the server, e.g. due to network+ * error net::ERR_FAILED.+ *+ */+ addListener(event: 'requestfailed', listener: (request: Request) => any): this;++ /**+ * Emitted when a request finishes successfully after downloading the response body. For a successful response, the+ * sequence of events is `request`, `response` and `requestfinished`.+ */+ addListener(event: 'requestfinished', listener: (request: Request) => any): this;++ /**+ * Emitted when [response] status and headers are received for a request. For a successful response, the sequence of+ * events is `request`, `response` and `requestfinished`.+ */+ addListener(event: 'response', listener: (response: Response) => any): this;++ /**+ * Emitted when [WebSocket](https://playwright.dev/docs/api/class-websocket) request is sent.+ */+ addListener(event: 'websocket', listener: (webSocket: WebSocket) => any): this;++ /**+ * Emitted when a dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is spawned+ * by the page.+ */+ addListener(event: 'worker', listener: (worker: Worker) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'close', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'crash', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'dialog', listener: (dialog: Dialog) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'domcontentloaded', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'download', listener: (download: Download) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'filechooser', listener: (fileChooser: FileChooser) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'frameattached', listener: (frame: Frame) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'framedetached', listener: (frame: Frame) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'framenavigated', listener: (frame: Frame) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'load', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'pageerror', listener: (error: Error) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'popup', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'request', listener: (request: Request) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'requestfailed', listener: (request: Request) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'requestfinished', listener: (request: Request) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'response', listener: (response: Response) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'websocket', listener: (webSocket: WebSocket) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'worker', listener: (worker: Worker) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'close', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'crash', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'dialog', listener: (dialog: Dialog) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'domcontentloaded', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'download', listener: (download: Download) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'filechooser', listener: (fileChooser: FileChooser) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'frameattached', listener: (frame: Frame) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'framedetached', listener: (frame: Frame) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'framenavigated', listener: (frame: Frame) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'load', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'pageerror', listener: (error: Error) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'popup', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'request', listener: (request: Request) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'requestfailed', listener: (request: Request) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'requestfinished', listener: (request: Request) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'response', listener: (response: Response) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'websocket', listener: (webSocket: WebSocket) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'worker', listener: (worker: Worker) => any): this;++ /**+ * Emitted when the page closes.+ */+ prependListener(event: 'close', listener: (page: Page) => any): this;++ /**+ * Emitted when JavaScript within the page calls one of console API methods, e.g. `console.log` or `console.dir`.+ *+ * The arguments passed into `console.log` are available on the+ * [ConsoleMessage](https://playwright.dev/docs/api/class-consolemessage) event handler argument.+ *+ * **Usage**+ *+ * ```js+ * page.on('console', async msg => {+ * const values = [];+ * for (const arg of msg.args())+ * values.push(await arg.jsonValue());+ * console.log(...values);+ * });+ * await page.evaluate(() => console.log('hello', 5, { foo: 'bar' }));+ * ```+ *+ */+ prependListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Emitted when the page crashes. Browser pages might crash if they try to allocate too much memory. When the page+ * crashes, ongoing and subsequent operations will throw.+ *+ * The most common way to deal with crashes is to catch an exception:+ *+ * ```js+ * try {+ * // Crash might happen during a click.+ * await page.click('button');+ * // Or while waiting for an event.+ * await page.waitForEvent('popup');+ * } catch (e) {+ * // When the page crashes, exception message contains 'crash'.+ * }+ * ```+ *+ */+ prependListener(event: 'crash', listener: (page: Page) => any): this;++ /**+ * Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**+ * either [dialog.accept([promptText])](https://playwright.dev/docs/api/class-dialog#dialog-accept) or+ * [dialog.dismiss()](https://playwright.dev/docs/api/class-dialog#dialog-dismiss) the dialog - otherwise the page+ * will [freeze](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#never_blocking) waiting for the+ * dialog, and actions like click will never finish.+ *+ * **Usage**+ *+ * ```js+ * page.on('dialog', dialog => dialog.accept());+ * ```+ *+ * **NOTE** When no [page.on('dialog')](https://playwright.dev/docs/api/class-page#page-event-dialog) or+ * [browserContext.on('dialog')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-dialog)+ * listeners are present, all dialogs are automatically dismissed.+ *+ */+ prependListener(event: 'dialog', listener: (dialog: Dialog) => any): this;++ /**+ * Emitted when the JavaScript+ * [`DOMContentLoaded`](https://developer.mozilla.org/en-US/docs/Web/Events/DOMContentLoaded) event is dispatched.+ */+ prependListener(event: 'domcontentloaded', listener: (page: Page) => any): this;++ /**+ * Emitted when attachment download started. User can access basic file operations on downloaded content via the+ * passed [Download](https://playwright.dev/docs/api/class-download) instance.+ */+ prependListener(event: 'download', listener: (download: Download) => any): this;++ /**+ * Emitted when a file chooser is supposed to appear, such as after clicking the `<input type=file>`. Playwright can+ * respond to it via setting the input files using+ * [fileChooser.setFiles(files[, options])](https://playwright.dev/docs/api/class-filechooser#file-chooser-set-files)+ * that can be uploaded after that.+ *+ * ```js+ * page.on('filechooser', async fileChooser => {+ * await fileChooser.setFiles(path.join(__dirname, '/tmp/myfile.pdf'));+ * });+ * ```+ *+ */+ prependListener(event: 'filechooser', listener: (fileChooser: FileChooser) => any): this;++ /**+ * Emitted when a frame is attached.+ */+ prependListener(event: 'frameattached', listener: (frame: Frame) => any): this;++ /**+ * Emitted when a frame is detached.+ */+ prependListener(event: 'framedetached', listener: (frame: Frame) => any): this;++ /**+ * Emitted when a frame is navigated to a new url.+ */+ prependListener(event: 'framenavigated', listener: (frame: Frame) => any): this;++ /**+ * Emitted when the JavaScript [`load`](https://developer.mozilla.org/en-US/docs/Web/Events/load) event is dispatched.+ */+ prependListener(event: 'load', listener: (page: Page) => any): this;++ /**+ * Emitted when an uncaught exception happens within the page.+ *+ * ```js+ * // Log all uncaught errors to the terminal+ * page.on('pageerror', exception => {+ * console.log(`Uncaught exception: "${exception}"`);+ * });+ *+ * // Navigate to a page with an exception.+ * await page.goto('data:text/html,<script>throw new Error("Test")</script>');+ * ```+ *+ */+ prependListener(event: 'pageerror', listener: (error: Error) => any): this;++ /**+ * Emitted when the page opens a new tab or window. This event is emitted in addition to the+ * [browserContext.on('page')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-page), but+ * only for popups relevant to this page.+ *+ * The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a+ * popup with `window.open('http://example.com')`, this event will fire when the network request to+ * "http://example.com" is done and its response has started loading in the popup. If you would like to route/listen+ * to this network request, use+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * and+ * [browserContext.on('request')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request)+ * respectively instead of similar methods on the [Page](https://playwright.dev/docs/api/class-page).+ *+ * ```js+ * // Start waiting for popup before clicking. Note no await.+ * const popupPromise = page.waitForEvent('popup');+ * await page.getByText('open the popup').click();+ * const popup = await popupPromise;+ * console.log(await popup.evaluate('location.href'));+ * ```+ *+ * **NOTE** Use+ * [page.waitForLoadState([state, options])](https://playwright.dev/docs/api/class-page#page-wait-for-load-state) to+ * wait until the page gets to a particular state (you should not need it in most cases).+ *+ */+ prependListener(event: 'popup', listener: (page: Page) => any): this;++ /**+ * Emitted when a page issues a request. The [request] object is read-only. In order to intercept and mutate requests,+ * see [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route) or+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route).+ */+ prependListener(event: 'request', listener: (request: Request) => any): this;++ /**+ * Emitted when a request fails, for example by timing out.+ *+ * ```js+ * page.on('requestfailed', request => {+ * console.log(request.url() + ' ' + request.failure().errorText);+ * });+ * ```+ *+ * **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request+ * will complete with+ * [page.on('requestfinished')](https://playwright.dev/docs/api/class-page#page-event-request-finished) event and not+ * with [page.on('requestfailed')](https://playwright.dev/docs/api/class-page#page-event-request-failed). A request+ * will only be considered failed when the client cannot get an HTTP response from the server, e.g. due to network+ * error net::ERR_FAILED.+ *+ */+ prependListener(event: 'requestfailed', listener: (request: Request) => any): this;++ /**+ * Emitted when a request finishes successfully after downloading the response body. For a successful response, the+ * sequence of events is `request`, `response` and `requestfinished`.+ */+ prependListener(event: 'requestfinished', listener: (request: Request) => any): this;++ /**+ * Emitted when [response] status and headers are received for a request. For a successful response, the sequence of+ * events is `request`, `response` and `requestfinished`.+ */+ prependListener(event: 'response', listener: (response: Response) => any): this;++ /**+ * Emitted when [WebSocket](https://playwright.dev/docs/api/class-websocket) request is sent.+ */+ prependListener(event: 'websocket', listener: (webSocket: WebSocket) => any): this;++ /**+ * Emitted when a dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is spawned+ * by the page.+ */+ prependListener(event: 'worker', listener: (worker: Worker) => any): this;++ /**+ * When testing a web page, sometimes unexpected overlays like a "Sign up" dialog appear and block actions you want to+ * automate, e.g. clicking a button. These overlays don't always show up in the same way or at the same time, making+ * them tricky to handle in automated tests.+ *+ * This method lets you set up a special function, called a handler, that activates when it detects that overlay is+ * visible. The handler's job is to remove the overlay, allowing your test to continue as if the overlay wasn't there.+ *+ * Things to keep in mind:+ * - When an overlay is shown predictably, we recommend explicitly waiting for it in your test and dismissing it as+ * a part of your normal test flow, instead of using+ * [page.addLocatorHandler(locator, handler[, options])](https://playwright.dev/docs/api/class-page#page-add-locator-handler).+ * - Playwright checks for the overlay every time before executing or retrying an action that requires an+ * [actionability check](https://playwright.dev/docs/actionability), or before performing an auto-waiting assertion check. When overlay+ * is visible, Playwright calls the handler first, and then proceeds with the action/assertion. Note that the+ * handler is only called when you perform an action/assertion - if the overlay becomes visible but you don't+ * perform any actions, the handler will not be triggered.+ * - After executing the handler, Playwright will ensure that overlay that triggered the handler is not visible+ * anymore. You can opt-out of this behavior with+ * [`noWaitAfter`](https://playwright.dev/docs/api/class-page#page-add-locator-handler-option-no-wait-after).+ * - The execution time of the handler counts towards the timeout of the action/assertion that executed the handler.+ * If your handler takes too long, it might cause timeouts.+ * - You can register multiple handlers. However, only a single handler will be running at a time. Make sure the+ * actions within a handler don't depend on another handler.+ *+ * **NOTE** Running the handler will alter your page state mid-test. For example it will change the currently focused+ * element and move the mouse. Make sure that actions that run after the handler are self-contained and do not rely on+ * the focus and mouse state being unchanged.+ *+ * For example, consider a test that calls+ * [locator.focus([options])](https://playwright.dev/docs/api/class-locator#locator-focus) followed by+ * [keyboard.press(key[, options])](https://playwright.dev/docs/api/class-keyboard#keyboard-press). If your handler+ * clicks a button between these two actions, the focused element most likely will be wrong, and key press will happen+ * on the unexpected element. Use+ * [locator.press(key[, options])](https://playwright.dev/docs/api/class-locator#locator-press) instead to avoid this+ * problem.+ *+ * Another example is a series of mouse actions, where+ * [mouse.move(x, y[, options])](https://playwright.dev/docs/api/class-mouse#mouse-move) is followed by+ * [mouse.down([options])](https://playwright.dev/docs/api/class-mouse#mouse-down). Again, when the handler runs+ * between these two actions, the mouse position will be wrong during the mouse down. Prefer self-contained actions+ * like [locator.click([options])](https://playwright.dev/docs/api/class-locator#locator-click) that do not rely on+ * the state being unchanged by a handler.+ *+ * **Usage**+ *+ * An example that closes a "Sign up to the newsletter" dialog when it appears:+ *+ * ```js+ * // Setup the handler.+ * await page.addLocatorHandler(page.getByText('Sign up to the newsletter'), async () => {+ * await page.getByRole('button', { name: 'No thanks' }).click();+ * });+ *+ * // Write the test as usual.+ * await page.goto('https://example.com');+ * await page.getByRole('button', { name: 'Start here' }).click();+ * ```+ *+ * An example that skips the "Confirm your security details" page when it is shown:+ *+ * ```js+ * // Setup the handler.+ * await page.addLocatorHandler(page.getByText('Confirm your security details'), async () => {+ * await page.getByRole('button', { name: 'Remind me later' }).click();+ * });+ *+ * // Write the test as usual.+ * await page.goto('https://example.com');+ * await page.getByRole('button', { name: 'Start here' }).click();+ * ```+ *+ * An example with a custom callback on every actionability check. It uses a `<body>` locator that is always visible,+ * so the handler is called before every actionability check. It is important to specify+ * [`noWaitAfter`](https://playwright.dev/docs/api/class-page#page-add-locator-handler-option-no-wait-after), because+ * the handler does not hide the `<body>` element.+ *+ * ```js+ * // Setup the handler.+ * await page.addLocatorHandler(page.locator('body'), async () => {+ * await page.evaluate(() => window.removeObstructionsForTestIfNeeded());+ * }, { noWaitAfter: true });+ *+ * // Write the test as usual.+ * await page.goto('https://example.com');+ * await page.getByRole('button', { name: 'Start here' }).click();+ * ```+ *+ * Handler takes the original locator as an argument. You can also automatically remove the handler after a number of+ * invocations by setting [`times`](https://playwright.dev/docs/api/class-page#page-add-locator-handler-option-times):+ *+ * ```js+ * await page.addLocatorHandler(page.getByLabel('Close'), async locator => {+ * await locator.click();+ * }, { times: 1 });+ * ```+ *+ * @param locator Locator that triggers the handler.+ * @param handler Function that should be run once+ * [`locator`](https://playwright.dev/docs/api/class-page#page-add-locator-handler-option-locator) appears. This+ * function should get rid of the element that blocks actions like click.+ * @param options+ */+ addLocatorHandler(locator: Locator, handler: ((locator: Locator) => Promise<any>), options?: {+ /**+ * By default, after calling the handler Playwright will wait until the overlay becomes hidden, and only then+ * Playwright will continue with the action/assertion that triggered the handler. This option allows to opt-out of+ * this behavior, so that overlay can stay visible after the handler has run.+ */+ noWaitAfter?: boolean;++ /**+ * Specifies the maximum number of times this handler should be called. Unlimited by default.+ */+ times?: number;+ }): Promise<void>;++ /**+ * Adds a `<script>` tag into the page with the desired url or content. Returns the added tag when the script's onload+ * fires or when the script content was injected into frame.+ * @param options+ */+ addScriptTag(options?: {+ /**+ * Raw JavaScript content to be injected into frame.+ */+ content?: string;++ /**+ * Path to the JavaScript file to be injected into frame. If `path` is a relative path, then it is resolved relative+ * to the current working directory.+ */+ path?: string;++ /**+ * Script type. Use 'module' in order to load a JavaScript ES6 module. See+ * [script](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script) for more details.+ */+ type?: string;++ /**+ * URL of a script to be added.+ */+ url?: string;+ }): Promise<ElementHandle>;++ /**+ * Adds a `<link rel="stylesheet">` tag into the page with the desired url or a `<style type="text/css">` tag with the+ * content. Returns the added tag when the stylesheet's onload fires or when the CSS content was injected into frame.+ * @param options+ */+ addStyleTag(options?: {+ /**+ * Raw CSS content to be injected into frame.+ */+ content?: string;++ /**+ * Path to the CSS file to be injected into frame. If `path` is a relative path, then it is resolved relative to the+ * current working directory.+ */+ path?: string;++ /**+ * URL of the `<link>` tag.+ */+ url?: string;+ }): Promise<ElementHandle>;++ /**+ * Brings page to front (activates tab).+ */+ bringToFront(): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.check([options])](https://playwright.dev/docs/api/class-locator#locator-check) instead.+ * Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method checks an element matching+ * [`selector`](https://playwright.dev/docs/api/class-page#page-check-option-selector) by performing the following+ * steps:+ * 1. Find an element matching [`selector`](https://playwright.dev/docs/api/class-page#page-check-option-selector).+ * If there is none, wait until a matching element is attached to the DOM.+ * 1. Ensure that matched element is a checkbox or a radio input. If not, this method throws. If the element is+ * already checked, this method returns immediately.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-page#page-check-option-force) option is set. If the element+ * is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element.+ * 1. Ensure that the element is now checked. If not, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-page#page-check-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ check(selector: string, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.click([options])](https://playwright.dev/docs/api/class-locator#locator-click) instead.+ * Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method clicks an element matching+ * [`selector`](https://playwright.dev/docs/api/class-page#page-click-option-selector) by performing the following+ * steps:+ * 1. Find an element matching [`selector`](https://playwright.dev/docs/api/class-page#page-click-option-selector).+ * If there is none, wait until a matching element is attached to the DOM.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-page#page-click-option-force) option is set. If the element+ * is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-page#page-click-option-position).+ * 1. Wait for initiated navigations to either succeed or fail, unless+ * [`noWaitAfter`](https://playwright.dev/docs/api/class-page#page-click-option-no-wait-after) option is set.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-page#page-click-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ click(selector: string, options?: {+ /**+ * Defaults to `left`.+ */+ button?: "left"|"right"|"middle";++ /**+ * defaults to 1. See [UIEvent.detail].+ */+ clickCount?: number;++ /**+ * Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You+ * can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as+ * navigating to inaccessible pages. Defaults to `false`.+ * @deprecated This option will default to `true` in the future.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard+ * `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys+ * are pressed.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * If [`runBeforeUnload`](https://playwright.dev/docs/api/class-page#page-close-option-run-before-unload) is `false`,+ * does not run any unload handlers and waits for the page to be closed. If+ * [`runBeforeUnload`](https://playwright.dev/docs/api/class-page#page-close-option-run-before-unload) is `true` the+ * method will run unload handlers, but will **not** wait for the page to close.+ *+ * By default, `page.close()` **does not** run `beforeunload` handlers.+ *+ * **NOTE** if [`runBeforeUnload`](https://playwright.dev/docs/api/class-page#page-close-option-run-before-unload) is+ * passed as true, a `beforeunload` dialog might be summoned and should be handled manually via+ * [page.on('dialog')](https://playwright.dev/docs/api/class-page#page-event-dialog) event.+ *+ * @param options+ */+ close(options?: {+ /**+ * The reason to be reported to the operations interrupted by the page closure.+ */+ reason?: string;++ /**+ * Defaults to `false`. Whether to run the+ * [before unload](https://developer.mozilla.org/en-US/docs/Web/Events/beforeunload) page handlers.+ */+ runBeforeUnload?: boolean;+ }): Promise<void>;++ /**+ * Gets the full HTML contents of the page, including the doctype.+ */+ content(): Promise<string>;++ /**+ * Get the browser context that the page belongs to.+ */+ context(): BrowserContext;++ /**+ * **NOTE** Use locator-based [locator.dblclick([options])](https://playwright.dev/docs/api/class-locator#locator-dblclick)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method double clicks an element matching+ * [`selector`](https://playwright.dev/docs/api/class-page#page-dblclick-option-selector) by performing the following+ * steps:+ * 1. Find an element matching+ * [`selector`](https://playwright.dev/docs/api/class-page#page-dblclick-option-selector). If there is none,+ * wait until a matching element is attached to the DOM.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-page#page-dblclick-option-force) option is set. If the+ * element is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to double click in the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-page#page-dblclick-option-position).+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-page#page-dblclick-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ *+ * **NOTE** `page.dblclick()` dispatches two `click` events and a single `dblclick` event.+ *+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ dblclick(selector: string, options?: {+ /**+ * Defaults to `left`.+ */+ button?: "left"|"right"|"middle";++ /**+ * Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard+ * `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys+ * are pressed.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based+ * [locator.dispatchEvent(type[, eventInit, options])](https://playwright.dev/docs/api/class-locator#locator-dispatch-event)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the element,+ * `click` is dispatched. This is equivalent to calling+ * [element.click()](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click).+ *+ * **Usage**+ *+ * ```js+ * await page.dispatchEvent('button#submit', 'click');+ * ```+ *+ * Under the hood, it creates an instance of an event based on the given+ * [`type`](https://playwright.dev/docs/api/class-page#page-dispatch-event-option-type), initializes it with+ * [`eventInit`](https://playwright.dev/docs/api/class-page#page-dispatch-event-option-event-init) properties and+ * dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.+ *+ * Since [`eventInit`](https://playwright.dev/docs/api/class-page#page-dispatch-event-option-event-init) is+ * event-specific, please refer to the events documentation for the lists of initial properties:+ * - [DeviceMotionEvent](https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent/DeviceMotionEvent)+ * - [DeviceOrientationEvent](https://developer.mozilla.org/en-US/docs/Web/API/DeviceOrientationEvent/DeviceOrientationEvent)+ * - [DragEvent](https://developer.mozilla.org/en-US/docs/Web/API/DragEvent/DragEvent)+ * - [Event](https://developer.mozilla.org/en-US/docs/Web/API/Event/Event)+ * - [FocusEvent](https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent/FocusEvent)+ * - [KeyboardEvent](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/KeyboardEvent)+ * - [MouseEvent](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/MouseEvent)+ * - [PointerEvent](https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/PointerEvent)+ * - [TouchEvent](https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent/TouchEvent)+ * - [WheelEvent](https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/WheelEvent)+ *+ * You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:+ *+ * ```js+ * // Note you can only create DataTransfer in Chromium and Firefox+ * const dataTransfer = await page.evaluateHandle(() => new DataTransfer());+ * await page.dispatchEvent('#source', 'dragstart', { dataTransfer });+ * ```+ *+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param type DOM event type: `"click"`, `"dragstart"`, etc.+ * @param eventInit Optional event-specific initialization properties.+ * @param options+ */+ dispatchEvent(selector: string, type: string, eventInit?: EvaluationArgument, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * This method drags the source element to the target element. It will first move to the source element, perform a+ * `mousedown`, then move to the target element and perform a `mouseup`.+ *+ * **Usage**+ *+ * ```js+ * await page.dragAndDrop('#source', '#target');+ * // or specify exact positions relative to the top-left corners of the elements:+ * await page.dragAndDrop('#source', '#target', {+ * sourcePosition: { x: 34, y: 7 },+ * targetPosition: { x: 10, y: 20 },+ * });+ * ```+ *+ * @param source A selector to search for an element to drag. If there are multiple elements satisfying the selector, the first will+ * be used.+ * @param target A selector to search for an element to drop onto. If there are multiple elements satisfying the selector, the first+ * will be used.+ * @param options+ */+ dragAndDrop(source: string, target: string, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * Clicks on the source element at this point relative to the top-left corner of the element's padding box. If not+ * specified, some visible point of the element is used.+ */+ sourcePosition?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Drops on the target element at this point relative to the top-left corner of the element's padding box. If not+ * specified, some visible point of the element is used.+ */+ targetPosition?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * This method changes the `CSS media type` through the `media` argument, and/or the `'prefers-colors-scheme'` media+ * feature, using the `colorScheme` argument.+ *+ * **Usage**+ *+ * ```js+ * await page.evaluate(() => matchMedia('screen').matches);+ * // → true+ * await page.evaluate(() => matchMedia('print').matches);+ * // → false+ *+ * await page.emulateMedia({ media: 'print' });+ * await page.evaluate(() => matchMedia('screen').matches);+ * // → false+ * await page.evaluate(() => matchMedia('print').matches);+ * // → true+ *+ * await page.emulateMedia({});+ * await page.evaluate(() => matchMedia('screen').matches);+ * // → true+ * await page.evaluate(() => matchMedia('print').matches);+ * // → false+ * ```+ *+ * ```js+ * await page.emulateMedia({ colorScheme: 'dark' });+ * await page.evaluate(() => matchMedia('(prefers-color-scheme: dark)').matches);+ * // → true+ * await page.evaluate(() => matchMedia('(prefers-color-scheme: light)').matches);+ * // → false+ * ```+ *+ * @param options+ */+ emulateMedia(options?: {+ /**+ * Emulates [prefers-colors-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)+ * media feature, supported values are `'light'` and `'dark'`. Passing `null` disables color scheme emulation.+ * `'no-preference'` is deprecated.+ */+ colorScheme?: null|"light"|"dark"|"no-preference";++ /**+ * Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. Passing `null`+ * disables contrast emulation.+ */+ contrast?: null|"no-preference"|"more";++ /**+ * Emulates `'forced-colors'` media feature, supported values are `'active'` and `'none'`. Passing `null` disables+ * forced colors emulation.+ */+ forcedColors?: null|"active"|"none";++ /**+ * Changes the CSS media type of the page. The only allowed values are `'screen'`, `'print'` and `null`. Passing+ * `null` disables CSS media emulation.+ */+ media?: null|"screen"|"print";++ /**+ * Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. Passing+ * `null` disables reduced motion emulation.+ */+ reducedMotion?: null|"reduce"|"no-preference";+ }): Promise<void>;++ /**+ * The method adds a function called+ * [`name`](https://playwright.dev/docs/api/class-page#page-expose-function-option-name) on the `window` object of+ * every frame in the page. When called, the function executes+ * [`callback`](https://playwright.dev/docs/api/class-page#page-expose-function-option-callback) and returns a+ * [Promise] which resolves to the return value of+ * [`callback`](https://playwright.dev/docs/api/class-page#page-expose-function-option-callback).+ *+ * If the [`callback`](https://playwright.dev/docs/api/class-page#page-expose-function-option-callback) returns a+ * [Promise], it will be awaited.+ *+ * See+ * [browserContext.exposeFunction(name, callback)](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-function)+ * for context-wide exposed function.+ *+ * **NOTE** Functions installed via+ * [page.exposeFunction(name, callback)](https://playwright.dev/docs/api/class-page#page-expose-function) survive+ * navigations.+ *+ * **Usage**+ *+ * An example of adding a `sha256` function to the page:+ *+ * ```js+ * const { webkit } = require('playwright'); // Or 'chromium' or 'firefox'.+ * const crypto = require('crypto');+ *+ * (async () => {+ * const browser = await webkit.launch({ headless: false });+ * const page = await browser.newPage();+ * await page.exposeFunction('sha256', text =>+ * crypto.createHash('sha256').update(text).digest('hex'),+ * );+ * await page.setContent(`+ * <script>+ * async function onClick() {+ * document.querySelector('div').textContent = await window.sha256('PLAYWRIGHT');+ * }+ * </script>+ * <button onclick="onClick()">Click me</button>+ * <div></div>+ * `);+ * await page.click('button');+ * })();+ * ```+ *+ * @param name Name of the function on the window object+ * @param callback Callback function which will be called in Playwright's context.+ */+ exposeFunction(name: string, callback: Function): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.fill(value[, options])](https://playwright.dev/docs/api/class-locator#locator-fill)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method waits for an element matching+ * [`selector`](https://playwright.dev/docs/api/class-page#page-fill-option-selector), waits for+ * [actionability](https://playwright.dev/docs/actionability) checks, focuses the element, fills it and triggers an `input` event after+ * filling. Note that you can pass an empty string to clear the input field.+ *+ * If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an+ * error. However, if the element is inside the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled+ * instead.+ *+ * To send fine-grained keyboard events, use+ * [locator.pressSequentially(text[, options])](https://playwright.dev/docs/api/class-locator#locator-press-sequentially).+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param value Value to fill for the `<input>`, `<textarea>` or `[contenteditable]` element.+ * @param options+ */+ fill(selector: string, value: string, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.focus([options])](https://playwright.dev/docs/api/class-locator#locator-focus) instead.+ * Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method fetches an element with+ * [`selector`](https://playwright.dev/docs/api/class-page#page-focus-option-selector) and focuses it. If there's no+ * element matching [`selector`](https://playwright.dev/docs/api/class-page#page-focus-option-selector), the method+ * waits until a matching element appears in the DOM.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ focus(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Returns frame matching the specified criteria. Either `name` or `url` must be specified.+ *+ * **Usage**+ *+ * ```js+ * const frame = page.frame('frame-name');+ * ```+ *+ * ```js+ * const frame = page.frame({ url: /.*domain.*\/ });+ * ```+ *+ * @param frameSelector Frame name or other frame lookup options.+ */+ frame(frameSelector: string|{+ /**+ * Frame name specified in the `iframe`'s `name` attribute. Optional.+ */+ name?: string;++ /**+ * A glob pattern, regex pattern or predicate receiving frame's `url` as a [URL] object. Optional.+ */+ url?: string|RegExp|((url: URL) => boolean);+ }): null|Frame;++ /**+ * When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements+ * in that iframe.+ *+ * **Usage**+ *+ * Following snippet locates element with text "Submit" in the iframe with id `my-frame`, like `<iframe+ * id="my-frame">`:+ *+ * ```js+ * const locator = page.frameLocator('#my-iframe').getByText('Submit');+ * await locator.click();+ * ```+ *+ * @param selector A selector to use when resolving DOM element.+ */+ frameLocator(selector: string): FrameLocator;++ /**+ * An array of all frames attached to the page.+ */+ frames(): Array<Frame>;++ /**+ * **NOTE** Use locator-based+ * [locator.getAttribute(name[, options])](https://playwright.dev/docs/api/class-locator#locator-get-attribute)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns element attribute value.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param name Attribute name to get the value for.+ * @param options+ */+ getAttribute(selector: string, name: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<null|string>;++ /**+ * Allows locating elements by their alt text.+ *+ * **Usage**+ *+ * For example, this method will find the image by alt text "Playwright logo":+ *+ * ```html+ * <img alt='Playwright logo'>+ * ```+ *+ * ```js+ * await page.getByAltText('Playwright logo').click();+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByAltText(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating input elements by the text of the associated `<label>` or `aria-labelledby` element, or by the+ * `aria-label` attribute.+ *+ * **Usage**+ *+ * For example, this method will find inputs by label "Username" and "Password" in the following DOM:+ *+ * ```html+ * <input aria-label="Username">+ * <label for="password-input">Password:</label>+ * <input id="password-input">+ * ```+ *+ * ```js+ * await page.getByLabel('Username').fill('john');+ * await page.getByLabel('Password').fill('secret');+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByLabel(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating input elements by the placeholder text.+ *+ * **Usage**+ *+ * For example, consider the following DOM structure.+ *+ * ```html+ * <input type="email" placeholder="[email protected]" />+ * ```+ *+ * You can fill the input after locating it by the placeholder text:+ *+ * ```js+ * await page+ * .getByPlaceholder('[email protected]')+ * .fill('[email protected]');+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByPlaceholder(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating elements by their [ARIA role](https://www.w3.org/TR/wai-aria-1.2/#roles),+ * [ARIA attributes](https://www.w3.org/TR/wai-aria-1.2/#aria-attributes) and+ * [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).+ *+ * **Usage**+ *+ * Consider the following DOM structure.+ *+ * ```html+ * <h3>Sign up</h3>+ * <label>+ * <input type="checkbox" /> Subscribe+ * </label>+ * <br/>+ * <button>Submit</button>+ * ```+ *+ * You can locate each element by it's implicit role:+ *+ * ```js+ * await expect(page.getByRole('heading', { name: 'Sign up' })).toBeVisible();+ *+ * await page.getByRole('checkbox', { name: 'Subscribe' }).check();+ *+ * await page.getByRole('button', { name: /submit/i }).click();+ * ```+ *+ * **Details**+ *+ * Role selector **does not replace** accessibility audits and conformance tests, but rather gives early feedback+ * about the ARIA guidelines.+ *+ * Many html elements have an implicitly [defined role](https://w3c.github.io/html-aam/#html-element-role-mappings)+ * that is recognized by the role selector. You can find all the+ * [supported roles here](https://www.w3.org/TR/wai-aria-1.2/#role_definitions). ARIA guidelines **do not recommend**+ * duplicating implicit roles and attributes by setting `role` and/or `aria-*` attributes to default values.+ * @param role Required aria role.+ * @param options+ */+ getByRole(role: "alert"|"alertdialog"|"application"|"article"|"banner"|"blockquote"|"button"|"caption"|"cell"|"checkbox"|"code"|"columnheader"|"combobox"|"complementary"|"contentinfo"|"definition"|"deletion"|"dialog"|"directory"|"document"|"emphasis"|"feed"|"figure"|"form"|"generic"|"grid"|"gridcell"|"group"|"heading"|"img"|"insertion"|"link"|"list"|"listbox"|"listitem"|"log"|"main"|"marquee"|"math"|"meter"|"menu"|"menubar"|"menuitem"|"menuitemcheckbox"|"menuitemradio"|"navigation"|"none"|"note"|"option"|"paragraph"|"presentation"|"progressbar"|"radio"|"radiogroup"|"region"|"row"|"rowgroup"|"rowheader"|"scrollbar"|"search"|"searchbox"|"separator"|"slider"|"spinbutton"|"status"|"strong"|"subscript"|"superscript"|"switch"|"tab"|"table"|"tablist"|"tabpanel"|"term"|"textbox"|"time"|"timer"|"toolbar"|"tooltip"|"tree"|"treegrid"|"treeitem", options?: {+ /**+ * An attribute that is usually set by `aria-checked` or native `<input type=checkbox>` controls.+ *+ * Learn more about [`aria-checked`](https://www.w3.org/TR/wai-aria-1.2/#aria-checked).+ */+ checked?: boolean;++ /**+ * An attribute that is usually set by `aria-disabled` or `disabled`.+ *+ * **NOTE** Unlike most other attributes, `disabled` is inherited through the DOM hierarchy. Learn more about+ * [`aria-disabled`](https://www.w3.org/TR/wai-aria-1.2/#aria-disabled).+ *+ */+ disabled?: boolean;++ /**+ * Whether [`name`](https://playwright.dev/docs/api/class-page#page-get-by-role-option-name) is matched exactly:+ * case-sensitive and whole-string. Defaults to false. Ignored when+ * [`name`](https://playwright.dev/docs/api/class-page#page-get-by-role-option-name) is a regular expression. Note+ * that exact match still trims whitespace.+ */+ exact?: boolean;++ /**+ * An attribute that is usually set by `aria-expanded`.+ *+ * Learn more about [`aria-expanded`](https://www.w3.org/TR/wai-aria-1.2/#aria-expanded).+ */+ expanded?: boolean;++ /**+ * Option that controls whether hidden elements are matched. By default, only non-hidden elements, as+ * [defined by ARIA](https://www.w3.org/TR/wai-aria-1.2/#tree_exclusion), are matched by role selector.+ *+ * Learn more about [`aria-hidden`](https://www.w3.org/TR/wai-aria-1.2/#aria-hidden).+ */+ includeHidden?: boolean;++ /**+ * A number attribute that is usually present for roles `heading`, `listitem`, `row`, `treeitem`, with default values+ * for `<h1>-<h6>` elements.+ *+ * Learn more about [`aria-level`](https://www.w3.org/TR/wai-aria-1.2/#aria-level).+ */+ level?: number;++ /**+ * Option to match the [accessible name](https://w3c.github.io/accname/#dfn-accessible-name). By default, matching is+ * case-insensitive and searches for a substring, use+ * [`exact`](https://playwright.dev/docs/api/class-page#page-get-by-role-option-exact) to control this behavior.+ *+ * Learn more about [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).+ */+ name?: string|RegExp;++ /**+ * An attribute that is usually set by `aria-pressed`.+ *+ * Learn more about [`aria-pressed`](https://www.w3.org/TR/wai-aria-1.2/#aria-pressed).+ */+ pressed?: boolean;++ /**+ * An attribute that is usually set by `aria-selected`.+ *+ * Learn more about [`aria-selected`](https://www.w3.org/TR/wai-aria-1.2/#aria-selected).+ */+ selected?: boolean;+ }): Locator;++ /**+ * Locate element by the test id.+ *+ * **Usage**+ *+ * Consider the following DOM structure.+ *+ * ```html+ * <button data-testid="directions">Itinéraire</button>+ * ```+ *+ * You can locate the element by it's test id:+ *+ * ```js+ * await page.getByTestId('directions').click();+ * ```+ *+ * **Details**+ *+ * By default, the `data-testid` attribute is used as a test id. Use+ * [selectors.setTestIdAttribute(attributeName)](https://playwright.dev/docs/api/class-selectors#selectors-set-test-id-attribute)+ * to configure a different test id attribute if necessary.+ *+ * ```js+ * // Set custom test id attribute from @playwright/test config:+ * import { defineConfig } from '@playwright/test';+ *+ * export default defineConfig({+ * use: {+ * testIdAttribute: 'data-pw'+ * },+ * });+ * ```+ *+ * @param testId Id to locate the element by.+ */+ getByTestId(testId: string|RegExp): Locator;++ /**+ * Allows locating elements that contain given text.+ *+ * See also [locator.filter([options])](https://playwright.dev/docs/api/class-locator#locator-filter) that allows to+ * match by another criteria, like an accessible role, and then filter by the text content.+ *+ * **Usage**+ *+ * Consider the following DOM structure:+ *+ * ```html+ * <div>Hello <span>world</span></div>+ * <div>Hello</div>+ * ```+ *+ * You can locate by text substring, exact string, or a regular expression:+ *+ * ```js+ * // Matches <span>+ * page.getByText('world');+ *+ * // Matches first <div>+ * page.getByText('Hello world');+ *+ * // Matches second <div>+ * page.getByText('Hello', { exact: true });+ *+ * // Matches both <div>s+ * page.getByText(/Hello/);+ *+ * // Matches second <div>+ * page.getByText(/^hello$/i);+ * ```+ *+ * **Details**+ *+ * Matching by text always normalizes whitespace, even with exact match. For example, it turns multiple spaces into+ * one, turns line breaks into spaces and ignores leading and trailing whitespace.+ *+ * Input elements of the type `button` and `submit` are matched by their `value` instead of the text content. For+ * example, locating by text `"Log in"` matches `<input type=button value="Log in">`.+ * @param text Text to locate the element for.+ * @param options+ */+ getByText(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating elements by their title attribute.+ *+ * **Usage**+ *+ * Consider the following DOM structure.+ *+ * ```html+ * <span title='Issues count'>25 issues</span>+ * ```+ *+ * You can check the issues count after locating it by the title text:+ *+ * ```js+ * await expect(page.getByTitle('Issues count')).toHaveText('25 issues');+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByTitle(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of+ * the last redirect. If cannot go back, returns `null`.+ *+ * Navigate to the previous page in history.+ * @param options+ */+ goBack(options?: {+ /**+ * Maximum operation time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via+ * `navigationTimeout` option in the config, or by using the+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout),+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout),+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When to consider operation succeeded, defaults to `load`. Events can be either:+ * - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.+ * - `'load'` - consider operation to be finished when the `load` event is fired.+ * - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for+ * at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.+ * - `'commit'` - consider operation to be finished when network response is received and the document started+ * loading.+ */+ waitUntil?: "load"|"domcontentloaded"|"networkidle"|"commit";+ }): Promise<null|Response>;++ /**+ * Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of+ * the last redirect. If cannot go forward, returns `null`.+ *+ * Navigate to the next page in history.+ * @param options+ */+ goForward(options?: {+ /**+ * Maximum operation time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via+ * `navigationTimeout` option in the config, or by using the+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout),+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout),+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When to consider operation succeeded, defaults to `load`. Events can be either:+ * - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.+ * - `'load'` - consider operation to be finished when the `load` event is fired.+ * - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for+ * at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.+ * - `'commit'` - consider operation to be finished when network response is received and the document started+ * loading.+ */+ waitUntil?: "load"|"domcontentloaded"|"networkidle"|"commit";+ }): Promise<null|Response>;++ /**+ * Returns the main resource response. In case of multiple redirects, the navigation will resolve with the first+ * non-redirect response.+ *+ * The method will throw an error if:+ * - there's an SSL error (e.g. in case of self-signed certificates).+ * - target URL is invalid.+ * - the [`timeout`](https://playwright.dev/docs/api/class-page#page-goto-option-timeout) is exceeded during+ * navigation.+ * - the remote server does not respond or is unreachable.+ * - the main resource failed to load.+ *+ * The method will not throw an error when any valid HTTP status code is returned by the remote server, including 404+ * "Not Found" and 500 "Internal Server Error". The status code for such responses can be retrieved by calling+ * [response.status()](https://playwright.dev/docs/api/class-response#response-status).+ *+ * **NOTE** The method either throws an error or returns a main resource response. The only exceptions are navigation+ * to `about:blank` or navigation to the same URL with a different hash, which would succeed and return `null`.+ *+ * **NOTE** Headless mode doesn't support navigation to a PDF document. See the+ * [upstream issue](https://bugs.chromium.org/p/chromium/issues/detail?id=761295).+ *+ * @param url URL to navigate page to. The url should include scheme, e.g. `https://`. When a+ * [`baseURL`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-base-url) via the context+ * options was provided and the passed URL is a path, it gets merged via the+ * [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.+ * @param options+ */+ goto(url: string, options?: {+ /**+ * Referer header value. If provided it will take preference over the referer header value set by+ * [page.setExtraHTTPHeaders(headers)](https://playwright.dev/docs/api/class-page#page-set-extra-http-headers).+ */+ referer?: string;++ /**+ * Maximum operation time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via+ * `navigationTimeout` option in the config, or by using the+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout),+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout),+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When to consider operation succeeded, defaults to `load`. Events can be either:+ * - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.+ * - `'load'` - consider operation to be finished when the `load` event is fired.+ * - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for+ * at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.+ * - `'commit'` - consider operation to be finished when network response is received and the document started+ * loading.+ */+ waitUntil?: "load"|"domcontentloaded"|"networkidle"|"commit";+ }): Promise<null|Response>;++ /**+ * **NOTE** Use locator-based [locator.hover([options])](https://playwright.dev/docs/api/class-locator#locator-hover) instead.+ * Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method hovers over an element matching+ * [`selector`](https://playwright.dev/docs/api/class-page#page-hover-option-selector) by performing the following+ * steps:+ * 1. Find an element matching [`selector`](https://playwright.dev/docs/api/class-page#page-hover-option-selector).+ * If there is none, wait until a matching element is attached to the DOM.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-page#page-hover-option-force) option is set. If the element+ * is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to hover over the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-page#page-hover-option-position).+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-page#page-hover-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ hover(selector: string, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard+ * `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys+ * are pressed.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.innerHTML([options])](https://playwright.dev/docs/api/class-locator#locator-inner-html)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns `element.innerHTML`.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ innerHTML(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<string>;++ /**+ * **NOTE** Use locator-based [locator.innerText([options])](https://playwright.dev/docs/api/class-locator#locator-inner-text)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns `element.innerText`.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ innerText(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<string>;++ /**+ * **NOTE** Use locator-based+ * [locator.inputValue([options])](https://playwright.dev/docs/api/class-locator#locator-input-value) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns `input.value` for the selected `<input>` or `<textarea>` or `<select>` element.+ *+ * Throws for non-input elements. However, if the element is inside the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), returns the value of the+ * control.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ inputValue(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<string>;++ /**+ * **NOTE** Use locator-based [locator.isChecked([options])](https://playwright.dev/docs/api/class-locator#locator-is-checked)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is checked. Throws if the element is not a checkbox or radio input.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ isChecked(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * Indicates that the page has been closed.+ */+ isClosed(): boolean;++ /**+ * **NOTE** Use locator-based+ * [locator.isDisabled([options])](https://playwright.dev/docs/api/class-locator#locator-is-disabled) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/docs/actionability#enabled).+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ isDisabled(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * **NOTE** Use locator-based+ * [locator.isEditable([options])](https://playwright.dev/docs/api/class-locator#locator-is-editable) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is [editable](https://playwright.dev/docs/actionability#editable).+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ isEditable(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * **NOTE** Use locator-based [locator.isEnabled([options])](https://playwright.dev/docs/api/class-locator#locator-is-enabled)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is [enabled](https://playwright.dev/docs/actionability#enabled).+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ isEnabled(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * **NOTE** Use locator-based [locator.isHidden([options])](https://playwright.dev/docs/api/class-locator#locator-is-hidden)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/docs/actionability#visible).+ * [`selector`](https://playwright.dev/docs/api/class-page#page-is-hidden-option-selector) that does not match any+ * elements is considered hidden.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ isHidden(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * @deprecated This option is ignored.+ * [page.isHidden(selector[, options])](https://playwright.dev/docs/api/class-page#page-is-hidden) does not wait for+ * the element to become hidden and returns immediately.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * **NOTE** Use locator-based [locator.isVisible([options])](https://playwright.dev/docs/api/class-locator#locator-is-visible)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is [visible](https://playwright.dev/docs/actionability#visible).+ * [`selector`](https://playwright.dev/docs/api/class-page#page-is-visible-option-selector) that does not match any+ * elements is considered not visible.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ isVisible(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * @deprecated This option is ignored.+ * [page.isVisible(selector[, options])](https://playwright.dev/docs/api/class-page#page-is-visible) does not wait for+ * the element to become visible and returns immediately.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * The method returns an element locator that can be used to perform actions on this page / frame. Locator is resolved+ * to the element immediately before performing an action, so a series of actions on the same locator can in fact be+ * performed on different DOM elements. That would happen if the DOM structure between those actions has changed.+ *+ * [Learn more about locators](https://playwright.dev/docs/locators).+ * @param selector A selector to use when resolving DOM element.+ * @param options+ */+ locator(selector: string, options?: {+ /**+ * Narrows down the results of the method to those which contain elements matching this relative locator. For example,+ * `article` that has `text=Playwright` matches `<article><div>Playwright</div></article>`.+ *+ * Inner locator **must be relative** to the outer locator and is queried starting with the outer locator match, not+ * the document root. For example, you can find `content` that has `div` in+ * `<article><content><div>Playwright</div></content></article>`. However, looking for `content` that has `article+ * div` will fail, because the inner locator must be relative and should not use any elements outside the `content`.+ *+ * Note that outer and inner locators must belong to the same frame. Inner locator must not contain+ * [FrameLocator](https://playwright.dev/docs/api/class-framelocator)s.+ */+ has?: Locator;++ /**+ * Matches elements that do not contain an element that matches an inner locator. Inner locator is queried against the+ * outer one. For example, `article` that does not have `div` matches `<article><span>Playwright</span></article>`.+ *+ * Note that outer and inner locators must belong to the same frame. Inner locator must not contain+ * [FrameLocator](https://playwright.dev/docs/api/class-framelocator)s.+ */+ hasNot?: Locator;++ /**+ * Matches elements that do not contain specified text somewhere inside, possibly in a child or a descendant element.+ * When passed a [string], matching is case-insensitive and searches for a substring.+ */+ hasNotText?: string|RegExp;++ /**+ * Matches elements containing specified text somewhere inside, possibly in a child or a descendant element. When+ * passed a [string], matching is case-insensitive and searches for a substring. For example, `"Playwright"` matches+ * `<article><div>Playwright</div></article>`.+ */+ hasText?: string|RegExp;+ }): Locator;++ /**+ * The page's main frame. Page is guaranteed to have a main frame which persists during navigations.+ */+ mainFrame(): Frame;++ /**+ * Returns the opener for popup pages and `null` for others. If the opener has been closed already the returns `null`.+ */+ opener(): Promise<null|Page>;++ /**+ * Pauses script execution. Playwright will stop executing the script and wait for the user to either press 'Resume'+ * button in the page overlay or to call `playwright.resume()` in the DevTools console.+ *+ * User can inspect selectors or perform manual steps while paused. Resume will continue running the original script+ * from the place it was paused.+ *+ * **NOTE** This method requires Playwright to be started in a headed mode, with a falsy+ * [`headless`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-option-headless) option.+ *+ */+ pause(): Promise<void>;++ /**+ * Returns the PDF buffer.+ *+ * `page.pdf()` generates a pdf of the page with `print` css media. To generate a pdf with `screen` media, call+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) before calling+ * `page.pdf()`:+ *+ * **NOTE** By default, `page.pdf()` generates a pdf with modified colors for printing. Use the+ * [`-webkit-print-color-adjust`](https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-print-color-adjust)+ * property to force rendering of exact colors.+ *+ * **Usage**+ *+ * ```js+ * // Generates a PDF with 'screen' media type.+ * await page.emulateMedia({ media: 'screen' });+ * await page.pdf({ path: 'page.pdf' });+ * ```+ *+ * The [`width`](https://playwright.dev/docs/api/class-page#page-pdf-option-width),+ * [`height`](https://playwright.dev/docs/api/class-page#page-pdf-option-height), and+ * [`margin`](https://playwright.dev/docs/api/class-page#page-pdf-option-margin) options accept values labeled with+ * units. Unlabeled values are treated as pixels.+ *+ * A few examples:+ * - `page.pdf({width: 100})` - prints with width set to 100 pixels+ * - `page.pdf({width: '100px'})` - prints with width set to 100 pixels+ * - `page.pdf({width: '10cm'})` - prints with width set to 10 centimeters.+ *+ * All possible units are:+ * - `px` - pixel+ * - `in` - inch+ * - `cm` - centimeter+ * - `mm` - millimeter+ *+ * The [`format`](https://playwright.dev/docs/api/class-page#page-pdf-option-format) options are:+ * - `Letter`: 8.5in x 11in+ * - `Legal`: 8.5in x 14in+ * - `Tabloid`: 11in x 17in+ * - `Ledger`: 17in x 11in+ * - `A0`: 33.1in x 46.8in+ * - `A1`: 23.4in x 33.1in+ * - `A2`: 16.54in x 23.4in+ * - `A3`: 11.7in x 16.54in+ * - `A4`: 8.27in x 11.7in+ * - `A5`: 5.83in x 8.27in+ * - `A6`: 4.13in x 5.83in+ *+ * **NOTE** [`headerTemplate`](https://playwright.dev/docs/api/class-page#page-pdf-option-header-template) and+ * [`footerTemplate`](https://playwright.dev/docs/api/class-page#page-pdf-option-footer-template) markup have the+ * following limitations: > 1. Script tags inside templates are not evaluated. > 2. Page styles are not visible inside+ * templates.+ *+ * @param options+ */+ pdf(options?: {+ /**+ * Display header and footer. Defaults to `false`.+ */+ displayHeaderFooter?: boolean;++ /**+ * HTML template for the print footer. Should use the same format as the+ * [`headerTemplate`](https://playwright.dev/docs/api/class-page#page-pdf-option-header-template).+ */+ footerTemplate?: string;++ /**+ * Paper format. If set, takes priority over+ * [`width`](https://playwright.dev/docs/api/class-page#page-pdf-option-width) or+ * [`height`](https://playwright.dev/docs/api/class-page#page-pdf-option-height) options. Defaults to 'Letter'.+ */+ format?: string;++ /**+ * HTML template for the print header. Should be valid HTML markup with following classes used to inject printing+ * values into them:+ * - `'date'` formatted print date+ * - `'title'` document title+ * - `'url'` document location+ * - `'pageNumber'` current page number+ * - `'totalPages'` total pages in the document+ */+ headerTemplate?: string;++ /**+ * Paper height, accepts values labeled with units.+ */+ height?: string|number;++ /**+ * Paper orientation. Defaults to `false`.+ */+ landscape?: boolean;++ /**+ * Paper margins, defaults to none.+ */+ margin?: {+ /**+ * Top margin, accepts values labeled with units. Defaults to `0`.+ */+ top?: string|number;++ /**+ * Right margin, accepts values labeled with units. Defaults to `0`.+ */+ right?: string|number;++ /**+ * Bottom margin, accepts values labeled with units. Defaults to `0`.+ */+ bottom?: string|number;++ /**+ * Left margin, accepts values labeled with units. Defaults to `0`.+ */+ left?: string|number;+ };++ /**+ * Whether or not to embed the document outline into the PDF. Defaults to `false`.+ */+ outline?: boolean;++ /**+ * Paper ranges to print, e.g., '1-5, 8, 11-13'. Defaults to the empty string, which means print all pages.+ */+ pageRanges?: string;++ /**+ * The file path to save the PDF to. If [`path`](https://playwright.dev/docs/api/class-page#page-pdf-option-path) is a+ * relative path, then it is resolved relative to the current working directory. If no path is provided, the PDF won't+ * be saved to the disk.+ */+ path?: string;++ /**+ * Give any CSS `@page` size declared in the page priority over what is declared in+ * [`width`](https://playwright.dev/docs/api/class-page#page-pdf-option-width) and+ * [`height`](https://playwright.dev/docs/api/class-page#page-pdf-option-height) or+ * [`format`](https://playwright.dev/docs/api/class-page#page-pdf-option-format) options. Defaults to `false`, which+ * will scale the content to fit the paper size.+ */+ preferCSSPageSize?: boolean;++ /**+ * Print background graphics. Defaults to `false`.+ */+ printBackground?: boolean;++ /**+ * Scale of the webpage rendering. Defaults to `1`. Scale amount must be between 0.1 and 2.+ */+ scale?: number;++ /**+ * Whether or not to generate tagged (accessible) PDF. Defaults to `false`.+ */+ tagged?: boolean;++ /**+ * Paper width, accepts values labeled with units.+ */+ width?: string|number;+ }): Promise<Buffer>;++ /**+ * **NOTE** Use locator-based [locator.press(key[, options])](https://playwright.dev/docs/api/class-locator#locator-press)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Focuses the element, and then uses+ * [keyboard.down(key)](https://playwright.dev/docs/api/class-keyboard#keyboard-down) and+ * [keyboard.up(key)](https://playwright.dev/docs/api/class-keyboard#keyboard-up).+ *+ * [`key`](https://playwright.dev/docs/api/class-page#page-press-option-key) can specify the intended+ * [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) value or a single character+ * to generate the text for. A superset of the+ * [`key`](https://playwright.dev/docs/api/class-page#page-press-option-key) values can be found+ * [here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:+ *+ * `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`,+ * `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,+ * etc.+ *+ * Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,+ * `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.+ *+ * Holding down `Shift` will type the text that corresponds to the+ * [`key`](https://playwright.dev/docs/api/class-page#page-press-option-key) in the upper case.+ *+ * If [`key`](https://playwright.dev/docs/api/class-page#page-press-option-key) is a single character, it is+ * case-sensitive, so the values `a` and `A` will generate different respective texts.+ *+ * Shortcuts such as `key: "Control+o"`, `key: "Control++` or `key: "Control+Shift+T"` are supported as well. When+ * specified with the modifier, modifier is pressed and being held while the subsequent key is being pressed.+ *+ * **Usage**+ *+ * ```js+ * const page = await browser.newPage();+ * await page.goto('https://keycode.info');+ * await page.press('body', 'A');+ * await page.screenshot({ path: 'A.png' });+ * await page.press('body', 'ArrowLeft');+ * await page.screenshot({ path: 'ArrowLeft.png' });+ * await page.press('body', 'Shift+O');+ * await page.screenshot({ path: 'O.png' });+ * await browser.close();+ * ```+ *+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param key Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.+ * @param options+ */+ press(selector: string, key: string, options?: {+ /**+ * Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You+ * can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as+ * navigating to inaccessible pages. Defaults to `false`.+ * @deprecated This option will default to `true` in the future.+ */+ noWaitAfter?: boolean;++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * This method reloads the current page, in the same way as if the user had triggered a browser refresh. Returns the+ * main resource response. In case of multiple redirects, the navigation will resolve with the response of the last+ * redirect.+ * @param options+ */+ reload(options?: {+ /**+ * Maximum operation time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via+ * `navigationTimeout` option in the config, or by using the+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout),+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout),+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When to consider operation succeeded, defaults to `load`. Events can be either:+ * - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.+ * - `'load'` - consider operation to be finished when the `load` event is fired.+ * - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for+ * at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.+ * - `'commit'` - consider operation to be finished when network response is received and the document started+ * loading.+ */+ waitUntil?: "load"|"domcontentloaded"|"networkidle"|"commit";+ }): Promise<null|Response>;++ /**+ * Removes all locator handlers added by+ * [page.addLocatorHandler(locator, handler[, options])](https://playwright.dev/docs/api/class-page#page-add-locator-handler)+ * for a specific locator.+ * @param locator Locator passed to+ * [page.addLocatorHandler(locator, handler[, options])](https://playwright.dev/docs/api/class-page#page-add-locator-handler).+ */+ removeLocatorHandler(locator: Locator): Promise<void>;++ /**+ * Request the page to perform garbage collection. Note that there is no guarantee that all unreachable objects will+ * be collected.+ *+ * This is useful to help detect memory leaks. For example, if your page has a large object `'suspect'` that might be+ * leaked, you can check that it does not leak by using a+ * [`WeakRef`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef).+ *+ * ```js+ * // 1. In your page, save a WeakRef for the "suspect".+ * await page.evaluate(() => globalThis.suspectWeakRef = new WeakRef(suspect));+ * // 2. Request garbage collection.+ * await page.requestGC();+ * // 3. Check that weak ref does not deref to the original object.+ * expect(await page.evaluate(() => !globalThis.suspectWeakRef.deref())).toBe(true);+ * ```+ *+ */+ requestGC(): Promise<void>;++ /**+ * Routing provides the capability to modify network requests that are made by a page.+ *+ * Once routing is enabled, every request matching the url pattern will stall unless it's continued, fulfilled or+ * aborted.+ *+ * **NOTE** The handler will only be called for the first url if the response is a redirect.+ *+ * **NOTE** [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route) will not+ * intercept requests intercepted by Service Worker. See [this](https://github.com/microsoft/playwright/issues/1090)+ * issue. We recommend disabling Service Workers when using request interception by setting+ * [`serviceWorkers`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-service-workers) to+ * `'block'`.+ *+ * **NOTE** [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route) will not+ * intercept the first request of a popup page. Use+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * instead.+ *+ * **Usage**+ *+ * An example of a naive handler that aborts all image requests:+ *+ * ```js+ * const page = await browser.newPage();+ * await page.route('**\/*.{png,jpg,jpeg}', route => route.abort());+ * await page.goto('https://example.com');+ * await browser.close();+ * ```+ *+ * or the same snippet using a regex pattern instead:+ *+ * ```js+ * const page = await browser.newPage();+ * await page.route(/(\.png$)|(\.jpg$)/, route => route.abort());+ * await page.goto('https://example.com');+ * await browser.close();+ * ```+ *+ * It is possible to examine the request to decide the route action. For example, mocking all requests that contain+ * some post data, and leaving all other requests as is:+ *+ * ```js+ * await page.route('/api/**', async route => {+ * if (route.request().postData().includes('my-string'))+ * await route.fulfill({ body: 'mocked-data' });+ * else+ * await route.continue();+ * });+ * ```+ *+ * Page routes take precedence over browser context routes (set up with+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route))+ * when request matches both handlers.+ *+ * To remove a route with its handler you can use+ * [page.unroute(url[, handler])](https://playwright.dev/docs/api/class-page#page-unroute).+ *+ * **NOTE** Enabling routing disables http cache.+ *+ * @param url A glob pattern, regex pattern or predicate receiving [URL] to match while routing. When a+ * [`baseURL`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-base-url) via the context+ * options was provided and the passed URL is a path, it gets merged via the+ * [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.+ * @param handler handler function to route the request.+ * @param options+ */+ route(url: string|RegExp|((url: URL) => boolean), handler: ((route: Route, request: Request) => Promise<any>|any), options?: {+ /**+ * How often a route should be used. By default it will be used every time.+ */+ times?: number;+ }): Promise<void>;++ /**+ * If specified the network requests that are made in the page will be served from the HAR file. Read more about+ * [Replaying from HAR](https://playwright.dev/docs/mock#replaying-from-har).+ *+ * Playwright will not serve requests intercepted by Service Worker from the HAR file. See+ * [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when+ * using request interception by setting+ * [`serviceWorkers`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-service-workers) to+ * `'block'`.+ * @param har Path to a [HAR](http://www.softwareishard.com/blog/har-12-spec) file with prerecorded network data. If `path` is a+ * relative path, then it is resolved relative to the current working directory.+ * @param options+ */+ routeFromHAR(har: string, options?: {+ /**+ * - If set to 'abort' any request not found in the HAR file will be aborted.+ * - If set to 'fallback' missing requests will be sent to the network.+ *+ * Defaults to abort.+ */+ notFound?: "abort"|"fallback";++ /**+ * If specified, updates the given HAR with the actual network information instead of serving from file. The file is+ * written to disk when+ * [browserContext.close([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-close) is+ * called.+ */+ update?: boolean;++ /**+ * Optional setting to control resource content management. If `attach` is specified, resources are persisted as+ * separate files or entries in the ZIP archive. If `embed` is specified, content is stored inline the HAR file.+ */+ updateContent?: "embed"|"attach";++ /**+ * When set to `minimal`, only record information necessary for routing from HAR. This omits sizes, timing, page,+ * cookies, security and other types of HAR information that are not used when replaying from HAR. Defaults to+ * `minimal`.+ */+ updateMode?: "full"|"minimal";++ /**+ * A glob pattern, regular expression or predicate to match the request URL. Only requests with URL matching the+ * pattern will be served from the HAR file. If not specified, all requests are served from the HAR file.+ */+ url?: string|RegExp;+ }): Promise<void>;++ /**+ * This method allows to modify websocket connections that are made by the page.+ *+ * Note that only `WebSocket`s created after this method was called will be routed. It is recommended to call this+ * method before navigating the page.+ *+ * **Usage**+ *+ * Below is an example of a simple mock that responds to a single message. See+ * [WebSocketRoute](https://playwright.dev/docs/api/class-websocketroute) for more details and examples.+ *+ * ```js+ * await page.routeWebSocket('/ws', ws => {+ * ws.onMessage(message => {+ * if (message === 'request')+ * ws.send('response');+ * });+ * });+ * ```+ *+ * @param url Only WebSockets with the url matching this pattern will be routed. A string pattern can be relative to the+ * [`baseURL`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-base-url) context option.+ * @param handler Handler function to route the WebSocket.+ */+ routeWebSocket(url: string|RegExp|((url: URL) => boolean), handler: ((websocketroute: WebSocketRoute) => Promise<any>|any)): Promise<void>;++ /**+ * Returns the buffer with the captured screenshot.+ * @param options+ */+ screenshot(options?: PageScreenshotOptions): Promise<Buffer>;++ /**+ * **NOTE** Use locator-based+ * [locator.selectOption(values[, options])](https://playwright.dev/docs/api/class-locator#locator-select-option)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method waits for an element matching+ * [`selector`](https://playwright.dev/docs/api/class-page#page-select-option-option-selector), waits for+ * [actionability](https://playwright.dev/docs/actionability) checks, waits until all specified options are present in the `<select>`+ * element and selects these options.+ *+ * If the target element is not a `<select>` element, this method throws an error. However, if the element is inside+ * the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be used+ * instead.+ *+ * Returns the array of option values that have been successfully selected.+ *+ * Triggers a `change` and `input` event once all the provided options have been selected.+ *+ * **Usage**+ *+ * ```js+ * // Single selection matching the value or label+ * page.selectOption('select#colors', 'blue');+ *+ * // single selection matching the label+ * page.selectOption('select#colors', { label: 'Blue' });+ *+ * // multiple selection+ * page.selectOption('select#colors', ['red', 'green', 'blue']);+ *+ * ```+ *+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param values Options to select. If the `<select>` has the `multiple` attribute, all matching options are selected, otherwise+ * only the first option matching one of the passed options is selected. String values are matching both values and+ * labels. Option is considered matching if all specified properties match.+ * @param options+ */+ selectOption(selector: string, values: null|string|ElementHandle|ReadonlyArray<string>|{+ /**+ * Matches by `option.value`. Optional.+ */+ value?: string;++ /**+ * Matches by `option.label`. Optional.+ */+ label?: string;++ /**+ * Matches by the index. Optional.+ */+ index?: number;+ }|ReadonlyArray<ElementHandle>|ReadonlyArray<{+ /**+ * Matches by `option.value`. Optional.+ */+ value?: string;++ /**+ * Matches by `option.label`. Optional.+ */+ label?: string;++ /**+ * Matches by the index. Optional.+ */+ index?: number;+ }>, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<Array<string>>;++ /**+ * **NOTE** Use locator-based+ * [locator.setChecked(checked[, options])](https://playwright.dev/docs/api/class-locator#locator-set-checked)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method checks or unchecks an element matching+ * [`selector`](https://playwright.dev/docs/api/class-page#page-set-checked-option-selector) by performing the+ * following steps:+ * 1. Find an element matching+ * [`selector`](https://playwright.dev/docs/api/class-page#page-set-checked-option-selector). If there is none,+ * wait until a matching element is attached to the DOM.+ * 1. Ensure that matched element is a checkbox or a radio input. If not, this method throws.+ * 1. If the element already has the right checked state, this method returns immediately.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-page#page-set-checked-option-force) option is set. If the+ * element is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element.+ * 1. Ensure that the element is now checked or unchecked. If not, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-page#page-set-checked-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param checked Whether to check or uncheck the checkbox.+ * @param options+ */+ setChecked(selector: string, checked: boolean, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * This method internally calls [document.write()](https://developer.mozilla.org/en-US/docs/Web/API/Document/write),+ * inheriting all its specific characteristics and behaviors.+ * @param html HTML markup to assign to the page.+ * @param options+ */+ setContent(html: string, options?: {+ /**+ * Maximum operation time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via+ * `navigationTimeout` option in the config, or by using the+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout),+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout),+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When to consider operation succeeded, defaults to `load`. Events can be either:+ * - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.+ * - `'load'` - consider operation to be finished when the `load` event is fired.+ * - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for+ * at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.+ * - `'commit'` - consider operation to be finished when network response is received and the document started+ * loading.+ */+ waitUntil?: "load"|"domcontentloaded"|"networkidle"|"commit";+ }): Promise<void>;++ /**+ * This setting will change the default maximum navigation time for the following methods and related shortcuts:+ * - [page.goBack([options])](https://playwright.dev/docs/api/class-page#page-go-back)+ * - [page.goForward([options])](https://playwright.dev/docs/api/class-page#page-go-forward)+ * - [page.goto(url[, options])](https://playwright.dev/docs/api/class-page#page-goto)+ * - [page.reload([options])](https://playwright.dev/docs/api/class-page#page-reload)+ * - [page.setContent(html[, options])](https://playwright.dev/docs/api/class-page#page-set-content)+ * - [page.waitForNavigation([options])](https://playwright.dev/docs/api/class-page#page-wait-for-navigation)+ * - [page.waitForURL(url[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-url)+ *+ * **NOTE**+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * takes priority over+ * [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout),+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * and+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout).+ *+ * @param timeout Maximum navigation time in milliseconds+ */+ setDefaultNavigationTimeout(timeout: number): void;++ /**+ * This setting will change the default maximum time for all the methods accepting+ * [`timeout`](https://playwright.dev/docs/api/class-page#page-set-default-timeout-option-timeout) option.+ *+ * **NOTE**+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * takes priority over+ * [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout).+ *+ * @param timeout Maximum time in milliseconds. Pass `0` to disable timeout.+ */+ setDefaultTimeout(timeout: number): void;++ /**+ * The extra HTTP headers will be sent with every request the page initiates.+ *+ * **NOTE**+ * [page.setExtraHTTPHeaders(headers)](https://playwright.dev/docs/api/class-page#page-set-extra-http-headers) does+ * not guarantee the order of headers in the outgoing requests.+ *+ * @param headers An object containing additional HTTP headers to be sent with every request. All header values must be strings.+ */+ setExtraHTTPHeaders(headers: { [key: string]: string; }): Promise<void>;++ /**+ * **NOTE** Use locator-based+ * [locator.setInputFiles(files[, options])](https://playwright.dev/docs/api/class-locator#locator-set-input-files)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Sets the value of the file input to these file paths or files. If some of the `filePaths` are relative paths, then+ * they are resolved relative to the current working directory. For empty array, clears the selected files. For inputs+ * with a `[webkitdirectory]` attribute, only a single directory path is supported.+ *+ * This method expects [`selector`](https://playwright.dev/docs/api/class-page#page-set-input-files-option-selector)+ * to point to an [input element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input). However, if the+ * element is inside the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), targets the control instead.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param files+ * @param options+ */+ setInputFiles(selector: string, files: string|ReadonlyArray<string>|{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }|ReadonlyArray<{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }>, options?: {+ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * In the case of multiple pages in a single browser, each page can have its own viewport size. However,+ * [browser.newContext([options])](https://playwright.dev/docs/api/class-browser#browser-new-context) allows to set+ * viewport size (and more) for all pages in the context at once.+ *+ * [page.setViewportSize(viewportSize)](https://playwright.dev/docs/api/class-page#page-set-viewport-size) will resize+ * the page. A lot of websites don't expect phones to change size, so you should set the viewport size before+ * navigating to the page.+ * [page.setViewportSize(viewportSize)](https://playwright.dev/docs/api/class-page#page-set-viewport-size) will also+ * reset `screen` size, use+ * [browser.newContext([options])](https://playwright.dev/docs/api/class-browser#browser-new-context) with `screen`+ * and `viewport` parameters if you need better control of these properties.+ *+ * **Usage**+ *+ * ```js+ * const page = await browser.newPage();+ * await page.setViewportSize({+ * width: 640,+ * height: 480,+ * });+ * await page.goto('https://example.com');+ * ```+ *+ * @param viewportSize+ */+ setViewportSize(viewportSize: {+ /**+ * page width in pixels.+ */+ width: number;++ /**+ * page height in pixels.+ */+ height: number;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.tap([options])](https://playwright.dev/docs/api/class-locator#locator-tap) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * This method taps an element matching+ * [`selector`](https://playwright.dev/docs/api/class-page#page-tap-option-selector) by performing the following+ * steps:+ * 1. Find an element matching [`selector`](https://playwright.dev/docs/api/class-page#page-tap-option-selector).+ * If there is none, wait until a matching element is attached to the DOM.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-page#page-tap-option-force) option is set. If the element is+ * detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.touchscreen](https://playwright.dev/docs/api/class-page#page-touchscreen) to tap the center of the+ * element, or the specified [`position`](https://playwright.dev/docs/api/class-page#page-tap-option-position).+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-page#page-tap-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ *+ * **NOTE** [page.tap(selector[, options])](https://playwright.dev/docs/api/class-page#page-tap) the method will throw+ * if [`hasTouch`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-has-touch) option of the+ * browser context is false.+ *+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ tap(selector: string, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard+ * `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys+ * are pressed.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based+ * [locator.textContent([options])](https://playwright.dev/docs/api/class-locator#locator-text-content) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns `element.textContent`.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ textContent(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<null|string>;++ /**+ * Returns the page's title.+ */+ title(): Promise<string>;++ /**+ * Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text. `page.type` can be used to+ * send fine-grained keyboard events. To fill values in form fields, use+ * [page.fill(selector, value[, options])](https://playwright.dev/docs/api/class-page#page-fill).+ *+ * To press a special key, like `Control` or `ArrowDown`, use+ * [keyboard.press(key[, options])](https://playwright.dev/docs/api/class-keyboard#keyboard-press).+ *+ * **Usage**+ * @deprecated In most cases, you should use+ * [locator.fill(value[, options])](https://playwright.dev/docs/api/class-locator#locator-fill) instead. You only need+ * to press keys one by one if there is special keyboard handling on the page - in this case use+ * [locator.pressSequentially(text[, options])](https://playwright.dev/docs/api/class-locator#locator-press-sequentially).+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param text A text to type into a focused element.+ * @param options+ */+ type(selector: string, text: string, options?: {+ /**+ * Time to wait between key presses in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.uncheck([options])](https://playwright.dev/docs/api/class-locator#locator-uncheck)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method unchecks an element matching+ * [`selector`](https://playwright.dev/docs/api/class-page#page-uncheck-option-selector) by performing the following+ * steps:+ * 1. Find an element matching+ * [`selector`](https://playwright.dev/docs/api/class-page#page-uncheck-option-selector). If there is none, wait+ * until a matching element is attached to the DOM.+ * 1. Ensure that matched element is a checkbox or a radio input. If not, this method throws. If the element is+ * already unchecked, this method returns immediately.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-page#page-uncheck-option-force) option is set. If the element+ * is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element.+ * 1. Ensure that the element is now unchecked. If not, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-page#page-uncheck-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ uncheck(selector: string, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * Removes a route created with+ * [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route). When+ * [`handler`](https://playwright.dev/docs/api/class-page#page-unroute-option-handler) is not specified, removes all+ * routes for the [`url`](https://playwright.dev/docs/api/class-page#page-unroute-option-url).+ * @param url A glob pattern, regex pattern or predicate receiving [URL] to match while routing.+ * @param handler Optional handler function to route the request.+ */+ unroute(url: string|RegExp|((url: URL) => boolean), handler?: ((route: Route, request: Request) => Promise<any>|any)): Promise<void>;++ /**+ * Removes all routes created with+ * [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route) and+ * [page.routeFromHAR(har[, options])](https://playwright.dev/docs/api/class-page#page-route-from-har).+ * @param options+ */+ unrouteAll(options?: {+ /**+ * Specifies whether to wait for already running handlers and what to do if they throw errors:+ * - `'default'` - do not wait for current handler calls (if any) to finish, if unrouted handler throws, it may+ * result in unhandled error+ * - `'wait'` - wait for current handler calls (if any) to finish+ * - `'ignoreErrors'` - do not wait for current handler calls (if any) to finish, all errors thrown by the handlers+ * after unrouting are silently caught+ */+ behavior?: "wait"|"ignoreErrors"|"default";+ }): Promise<void>;++ url(): string;++ /**+ * Video object associated with this page.+ */+ video(): null|Video;++ viewportSize(): null|{+ /**+ * page width in pixels.+ */+ width: number;++ /**+ * page height in pixels.+ */+ height: number;+ };++ /**+ * Emitted when the page closes.+ */+ waitForEvent(event: 'close', optionsOrPredicate?: { predicate?: (page: Page) => boolean | Promise<boolean>, timeout?: number } | ((page: Page) => boolean | Promise<boolean>)): Promise<Page>;++ /**+ * Emitted when JavaScript within the page calls one of console API methods, e.g. `console.log` or `console.dir`.+ *+ * The arguments passed into `console.log` are available on the+ * [ConsoleMessage](https://playwright.dev/docs/api/class-consolemessage) event handler argument.+ *+ * **Usage**+ *+ * ```js+ * page.on('console', async msg => {+ * const values = [];+ * for (const arg of msg.args())+ * values.push(await arg.jsonValue());+ * console.log(...values);+ * });+ * await page.evaluate(() => console.log('hello', 5, { foo: 'bar' }));+ * ```+ *+ */+ waitForEvent(event: 'console', optionsOrPredicate?: { predicate?: (consoleMessage: ConsoleMessage) => boolean | Promise<boolean>, timeout?: number } | ((consoleMessage: ConsoleMessage) => boolean | Promise<boolean>)): Promise<ConsoleMessage>;++ /**+ * Emitted when the page crashes. Browser pages might crash if they try to allocate too much memory. When the page+ * crashes, ongoing and subsequent operations will throw.+ *+ * The most common way to deal with crashes is to catch an exception:+ *+ * ```js+ * try {+ * // Crash might happen during a click.+ * await page.click('button');+ * // Or while waiting for an event.+ * await page.waitForEvent('popup');+ * } catch (e) {+ * // When the page crashes, exception message contains 'crash'.+ * }+ * ```+ *+ */+ waitForEvent(event: 'crash', optionsOrPredicate?: { predicate?: (page: Page) => boolean | Promise<boolean>, timeout?: number } | ((page: Page) => boolean | Promise<boolean>)): Promise<Page>;++ /**+ * Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**+ * either [dialog.accept([promptText])](https://playwright.dev/docs/api/class-dialog#dialog-accept) or+ * [dialog.dismiss()](https://playwright.dev/docs/api/class-dialog#dialog-dismiss) the dialog - otherwise the page+ * will [freeze](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#never_blocking) waiting for the+ * dialog, and actions like click will never finish.+ *+ * **Usage**+ *+ * ```js+ * page.on('dialog', dialog => dialog.accept());+ * ```+ *+ * **NOTE** When no [page.on('dialog')](https://playwright.dev/docs/api/class-page#page-event-dialog) or+ * [browserContext.on('dialog')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-dialog)+ * listeners are present, all dialogs are automatically dismissed.+ *+ */+ waitForEvent(event: 'dialog', optionsOrPredicate?: { predicate?: (dialog: Dialog) => boolean | Promise<boolean>, timeout?: number } | ((dialog: Dialog) => boolean | Promise<boolean>)): Promise<Dialog>;++ /**+ * Emitted when the JavaScript+ * [`DOMContentLoaded`](https://developer.mozilla.org/en-US/docs/Web/Events/DOMContentLoaded) event is dispatched.+ */+ waitForEvent(event: 'domcontentloaded', optionsOrPredicate?: { predicate?: (page: Page) => boolean | Promise<boolean>, timeout?: number } | ((page: Page) => boolean | Promise<boolean>)): Promise<Page>;++ /**+ * Emitted when attachment download started. User can access basic file operations on downloaded content via the+ * passed [Download](https://playwright.dev/docs/api/class-download) instance.+ */+ waitForEvent(event: 'download', optionsOrPredicate?: { predicate?: (download: Download) => boolean | Promise<boolean>, timeout?: number } | ((download: Download) => boolean | Promise<boolean>)): Promise<Download>;++ /**+ * Emitted when a file chooser is supposed to appear, such as after clicking the `<input type=file>`. Playwright can+ * respond to it via setting the input files using+ * [fileChooser.setFiles(files[, options])](https://playwright.dev/docs/api/class-filechooser#file-chooser-set-files)+ * that can be uploaded after that.+ *+ * ```js+ * page.on('filechooser', async fileChooser => {+ * await fileChooser.setFiles(path.join(__dirname, '/tmp/myfile.pdf'));+ * });+ * ```+ *+ */+ waitForEvent(event: 'filechooser', optionsOrPredicate?: { predicate?: (fileChooser: FileChooser) => boolean | Promise<boolean>, timeout?: number } | ((fileChooser: FileChooser) => boolean | Promise<boolean>)): Promise<FileChooser>;++ /**+ * Emitted when a frame is attached.+ */+ waitForEvent(event: 'frameattached', optionsOrPredicate?: { predicate?: (frame: Frame) => boolean | Promise<boolean>, timeout?: number } | ((frame: Frame) => boolean | Promise<boolean>)): Promise<Frame>;++ /**+ * Emitted when a frame is detached.+ */+ waitForEvent(event: 'framedetached', optionsOrPredicate?: { predicate?: (frame: Frame) => boolean | Promise<boolean>, timeout?: number } | ((frame: Frame) => boolean | Promise<boolean>)): Promise<Frame>;++ /**+ * Emitted when a frame is navigated to a new url.+ */+ waitForEvent(event: 'framenavigated', optionsOrPredicate?: { predicate?: (frame: Frame) => boolean | Promise<boolean>, timeout?: number } | ((frame: Frame) => boolean | Promise<boolean>)): Promise<Frame>;++ /**+ * Emitted when the JavaScript [`load`](https://developer.mozilla.org/en-US/docs/Web/Events/load) event is dispatched.+ */+ waitForEvent(event: 'load', optionsOrPredicate?: { predicate?: (page: Page) => boolean | Promise<boolean>, timeout?: number } | ((page: Page) => boolean | Promise<boolean>)): Promise<Page>;++ /**+ * Emitted when an uncaught exception happens within the page.+ *+ * ```js+ * // Log all uncaught errors to the terminal+ * page.on('pageerror', exception => {+ * console.log(`Uncaught exception: "${exception}"`);+ * });+ *+ * // Navigate to a page with an exception.+ * await page.goto('data:text/html,<script>throw new Error("Test")</script>');+ * ```+ *+ */+ waitForEvent(event: 'pageerror', optionsOrPredicate?: { predicate?: (error: Error) => boolean | Promise<boolean>, timeout?: number } | ((error: Error) => boolean | Promise<boolean>)): Promise<Error>;++ /**+ * Emitted when the page opens a new tab or window. This event is emitted in addition to the+ * [browserContext.on('page')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-page), but+ * only for popups relevant to this page.+ *+ * The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a+ * popup with `window.open('http://example.com')`, this event will fire when the network request to+ * "http://example.com" is done and its response has started loading in the popup. If you would like to route/listen+ * to this network request, use+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * and+ * [browserContext.on('request')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request)+ * respectively instead of similar methods on the [Page](https://playwright.dev/docs/api/class-page).+ *+ * ```js+ * // Start waiting for popup before clicking. Note no await.+ * const popupPromise = page.waitForEvent('popup');+ * await page.getByText('open the popup').click();+ * const popup = await popupPromise;+ * console.log(await popup.evaluate('location.href'));+ * ```+ *+ * **NOTE** Use+ * [page.waitForLoadState([state, options])](https://playwright.dev/docs/api/class-page#page-wait-for-load-state) to+ * wait until the page gets to a particular state (you should not need it in most cases).+ *+ */+ waitForEvent(event: 'popup', optionsOrPredicate?: { predicate?: (page: Page) => boolean | Promise<boolean>, timeout?: number } | ((page: Page) => boolean | Promise<boolean>)): Promise<Page>;++ /**+ * Emitted when a page issues a request. The [request] object is read-only. In order to intercept and mutate requests,+ * see [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route) or+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route).+ */+ waitForEvent(event: 'request', optionsOrPredicate?: { predicate?: (request: Request) => boolean | Promise<boolean>, timeout?: number } | ((request: Request) => boolean | Promise<boolean>)): Promise<Request>;++ /**+ * Emitted when a request fails, for example by timing out.+ *+ * ```js+ * page.on('requestfailed', request => {+ * console.log(request.url() + ' ' + request.failure().errorText);+ * });+ * ```+ *+ * **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request+ * will complete with+ * [page.on('requestfinished')](https://playwright.dev/docs/api/class-page#page-event-request-finished) event and not+ * with [page.on('requestfailed')](https://playwright.dev/docs/api/class-page#page-event-request-failed). A request+ * will only be considered failed when the client cannot get an HTTP response from the server, e.g. due to network+ * error net::ERR_FAILED.+ *+ */+ waitForEvent(event: 'requestfailed', optionsOrPredicate?: { predicate?: (request: Request) => boolean | Promise<boolean>, timeout?: number } | ((request: Request) => boolean | Promise<boolean>)): Promise<Request>;++ /**+ * Emitted when a request finishes successfully after downloading the response body. For a successful response, the+ * sequence of events is `request`, `response` and `requestfinished`.+ */+ waitForEvent(event: 'requestfinished', optionsOrPredicate?: { predicate?: (request: Request) => boolean | Promise<boolean>, timeout?: number } | ((request: Request) => boolean | Promise<boolean>)): Promise<Request>;++ /**+ * Emitted when [response] status and headers are received for a request. For a successful response, the sequence of+ * events is `request`, `response` and `requestfinished`.+ */+ waitForEvent(event: 'response', optionsOrPredicate?: { predicate?: (response: Response) => boolean | Promise<boolean>, timeout?: number } | ((response: Response) => boolean | Promise<boolean>)): Promise<Response>;++ /**+ * Emitted when [WebSocket](https://playwright.dev/docs/api/class-websocket) request is sent.+ */+ waitForEvent(event: 'websocket', optionsOrPredicate?: { predicate?: (webSocket: WebSocket) => boolean | Promise<boolean>, timeout?: number } | ((webSocket: WebSocket) => boolean | Promise<boolean>)): Promise<WebSocket>;++ /**+ * Emitted when a dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is spawned+ * by the page.+ */+ waitForEvent(event: 'worker', optionsOrPredicate?: { predicate?: (worker: Worker) => boolean | Promise<boolean>, timeout?: number } | ((worker: Worker) => boolean | Promise<boolean>)): Promise<Worker>;+++ /**+ * Returns when the required load state has been reached.+ *+ * This resolves when the page reaches a required load state, `load` by default. The navigation must have been+ * committed when this method is called. If current document has already reached the required state, resolves+ * immediately.+ *+ * **NOTE** Most of the time, this method is not needed because Playwright+ * [auto-waits before every action](https://playwright.dev/docs/actionability).+ *+ * **Usage**+ *+ * ```js+ * await page.getByRole('button').click(); // Click triggers navigation.+ * await page.waitForLoadState(); // The promise resolves after 'load' event.+ * ```+ *+ * ```js+ * const popupPromise = page.waitForEvent('popup');+ * await page.getByRole('button').click(); // Click triggers a popup.+ * const popup = await popupPromise;+ * await popup.waitForLoadState('domcontentloaded'); // Wait for the 'DOMContentLoaded' event.+ * console.log(await popup.title()); // Popup is ready to use.+ * ```+ *+ * @param state Optional load state to wait for, defaults to `load`. If the state has been already reached while loading current+ * document, the method resolves immediately. Can be one of:+ * - `'load'` - wait for the `load` event to be fired.+ * - `'domcontentloaded'` - wait for the `DOMContentLoaded` event to be fired.+ * - `'networkidle'` - **DISCOURAGED** wait until there are no network connections for at least `500` ms. Don't use+ * this method for testing, rely on web assertions to assess readiness instead.+ * @param options+ */+ waitForLoadState(state?: "load"|"domcontentloaded"|"networkidle", options?: {+ /**+ * Maximum operation time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via+ * `navigationTimeout` option in the config, or by using the+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout),+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout),+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Waits for the main frame navigation and returns the main resource response. In case of multiple redirects, the+ * navigation will resolve with the response of the last redirect. In case of navigation to a different anchor or+ * navigation due to History API usage, the navigation will resolve with `null`.+ *+ * **Usage**+ *+ * This resolves when the page navigates to a new URL or reloads. It is useful for when you run code which will+ * indirectly cause the page to navigate. e.g. The click target has an `onclick` handler that triggers navigation from+ * a `setTimeout`. Consider this example:+ *+ * ```js+ * // Start waiting for navigation before clicking. Note no await.+ * const navigationPromise = page.waitForNavigation();+ * await page.getByText('Navigate after timeout').click();+ * await navigationPromise;+ * ```+ *+ * **NOTE** Usage of the [History API](https://developer.mozilla.org/en-US/docs/Web/API/History_API) to change the URL+ * is considered a navigation.+ *+ * @deprecated This method is inherently racy, please use+ * [page.waitForURL(url[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-url) instead.+ * @param options+ */+ waitForNavigation(options?: {+ /**+ * Maximum operation time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via+ * `navigationTimeout` option in the config, or by using the+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout),+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout),+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * A glob pattern, regex pattern or predicate receiving [URL] to match while waiting for the navigation. Note that if+ * the parameter is a string without wildcard characters, the method will wait for navigation to URL that is exactly+ * equal to the string.+ */+ url?: string|RegExp|((url: URL) => boolean);++ /**+ * When to consider operation succeeded, defaults to `load`. Events can be either:+ * - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.+ * - `'load'` - consider operation to be finished when the `load` event is fired.+ * - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for+ * at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.+ * - `'commit'` - consider operation to be finished when network response is received and the document started+ * loading.+ */+ waitUntil?: "load"|"domcontentloaded"|"networkidle"|"commit";+ }): Promise<null|Response>;++ /**+ * Waits for the matching request and returns it. See [waiting for event](https://playwright.dev/docs/events#waiting-for-event) for more+ * details about events.+ *+ * **Usage**+ *+ * ```js+ * // Start waiting for request before clicking. Note no await.+ * const requestPromise = page.waitForRequest('https://example.com/resource');+ * await page.getByText('trigger request').click();+ * const request = await requestPromise;+ *+ * // Alternative way with a predicate. Note no await.+ * const requestPromise = page.waitForRequest(request =>+ * request.url() === 'https://example.com' && request.method() === 'GET',+ * );+ * await page.getByText('trigger request').click();+ * const request = await requestPromise;+ * ```+ *+ * @param urlOrPredicate Request URL string, regex or predicate receiving [Request](https://playwright.dev/docs/api/class-request) object.+ * @param options+ */+ waitForRequest(urlOrPredicate: string|RegExp|((request: Request) => boolean|Promise<boolean>), options?: {+ /**+ * Maximum wait time in milliseconds, defaults to 30 seconds, pass `0` to disable the timeout. The default value can+ * be changed by using the+ * [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) method.+ */+ timeout?: number;+ }): Promise<Request>;++ /**+ * Returns the matched response. See [waiting for event](https://playwright.dev/docs/events#waiting-for-event) for more details about+ * events.+ *+ * **Usage**+ *+ * ```js+ * // Start waiting for response before clicking. Note no await.+ * const responsePromise = page.waitForResponse('https://example.com/resource');+ * await page.getByText('trigger response').click();+ * const response = await responsePromise;+ *+ * // Alternative way with a predicate. Note no await.+ * const responsePromise = page.waitForResponse(response =>+ * response.url() === 'https://example.com' && response.status() === 200+ * && response.request().method() === 'GET'+ * );+ * await page.getByText('trigger response').click();+ * const response = await responsePromise;+ * ```+ *+ * @param urlOrPredicate Request URL string, regex or predicate receiving [Response](https://playwright.dev/docs/api/class-response) object.+ * When a [`baseURL`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-base-url) via the+ * context options was provided and the passed URL is a path, it gets merged via the+ * [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.+ * @param options+ */+ waitForResponse(urlOrPredicate: string|RegExp|((response: Response) => boolean|Promise<boolean>), options?: {+ /**+ * Maximum wait time in milliseconds, defaults to 30 seconds, pass `0` to disable the timeout. The default value can+ * be changed by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<Response>;++ /**+ * **NOTE** Never wait for timeout in production. Tests that wait for time are inherently flaky. Use+ * [Locator](https://playwright.dev/docs/api/class-locator) actions and web assertions that wait automatically.+ *+ * Waits for the given [`timeout`](https://playwright.dev/docs/api/class-page#page-wait-for-timeout-option-timeout) in+ * milliseconds.+ *+ * Note that `page.waitForTimeout()` should only be used for debugging. Tests using the timer in production are going+ * to be flaky. Use signals such as network events, selectors becoming visible and others instead.+ *+ * **Usage**+ *+ * ```js+ * // wait for 1 second+ * await page.waitForTimeout(1000);+ * ```+ *+ * @param timeout A timeout to wait for+ */+ waitForTimeout(timeout: number): Promise<void>;++ /**+ * Waits for the main frame to navigate to the given URL.+ *+ * **Usage**+ *+ * ```js+ * await page.click('a.delayed-navigation'); // Clicking the link will indirectly cause a navigation+ * await page.waitForURL('**\/target.html');+ * ```+ *+ * @param url A glob pattern, regex pattern or predicate receiving [URL] to match while waiting for the navigation. Note that if+ * the parameter is a string without wildcard characters, the method will wait for navigation to URL that is exactly+ * equal to the string.+ * @param options+ */+ waitForURL(url: string|RegExp|((url: URL) => boolean), options?: {+ /**+ * Maximum operation time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via+ * `navigationTimeout` option in the config, or by using the+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout),+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout),+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When to consider operation succeeded, defaults to `load`. Events can be either:+ * - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.+ * - `'load'` - consider operation to be finished when the `load` event is fired.+ * - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for+ * at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.+ * - `'commit'` - consider operation to be finished when network response is received and the document started+ * loading.+ */+ waitUntil?: "load"|"domcontentloaded"|"networkidle"|"commit";+ }): Promise<void>;++ /**+ * This method returns all of the dedicated+ * [WebWorkers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) associated with the page.+ *+ * **NOTE** This does not contain ServiceWorkers+ *+ */+ workers(): Array<Worker>;++ /**+ * @deprecated This property is discouraged. Please use other libraries such as [Axe](https://www.deque.com/axe/) if you need to+ * test page accessibility. See our Node.js [guide](https://playwright.dev/docs/accessibility-testing) for integration+ * with Axe.+ */+ accessibility: Accessibility;++ /**+ * Playwright has ability to mock clock and passage of time.+ */+ clock: Clock;++ /**+ * **NOTE** Only available for Chromium atm.+ *+ * Browser-specific Coverage implementation. See [Coverage](https://playwright.dev/docs/api/class-coverage) for more+ * details.+ */+ coverage: Coverage;++ keyboard: Keyboard;++ mouse: Mouse;++ /**+ * API testing helper associated with this page. This method returns the same instance as+ * [browserContext.request](https://playwright.dev/docs/api/class-browsercontext#browser-context-request) on the+ * page's context. See+ * [browserContext.request](https://playwright.dev/docs/api/class-browsercontext#browser-context-request) for more+ * details.+ */+ request: APIRequestContext;++ touchscreen: Touchscreen;++ [Symbol.asyncDispose](): Promise<void>;+}++/**+ * At every point of time, page exposes its current frame tree via the+ * [page.mainFrame()](https://playwright.dev/docs/api/class-page#page-main-frame) and+ * [frame.childFrames()](https://playwright.dev/docs/api/class-frame#frame-child-frames) methods.+ *+ * [Frame](https://playwright.dev/docs/api/class-frame) object's lifecycle is controlled by three events, dispatched+ * on the page object:+ * - [page.on('frameattached')](https://playwright.dev/docs/api/class-page#page-event-frame-attached) - fired when+ * the frame gets attached to the page. A Frame can be attached to the page only once.+ * - [page.on('framenavigated')](https://playwright.dev/docs/api/class-page#page-event-frame-navigated) - fired when+ * the frame commits navigation to a different URL.+ * - [page.on('framedetached')](https://playwright.dev/docs/api/class-page#page-event-frame-detached) - fired when+ * the frame gets detached from the page. A Frame can be detached from the page only once.+ *+ * An example of dumping frame tree:+ *+ * ```js+ * const { firefox } = require('playwright'); // Or 'chromium' or 'webkit'.+ *+ * (async () => {+ * const browser = await firefox.launch();+ * const page = await browser.newPage();+ * await page.goto('https://www.google.com/chrome/browser/canary.html');+ * dumpFrameTree(page.mainFrame(), '');+ * await browser.close();+ *+ * function dumpFrameTree(frame, indent) {+ * console.log(indent + frame.url());+ * for (const child of frame.childFrames())+ * dumpFrameTree(child, indent + ' ');+ * }+ * })();+ * ```+ *+ */+export interface Frame {+ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-option-expression).+ *+ * If the function passed to the+ * [frame.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate) returns a+ * [Promise], then [frame.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate)+ * would wait for the promise to resolve and return its value.+ *+ * If the function passed to the+ * [frame.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate) returns a+ * non-[Serializable] value, then+ * [frame.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate) returns+ * `undefined`. Playwright also supports transferring some additional values that are not serializable by `JSON`:+ * `-0`, `NaN`, `Infinity`, `-Infinity`.+ *+ * **Usage**+ *+ * ```js+ * const result = await frame.evaluate(([x, y]) => {+ * return Promise.resolve(x * y);+ * }, [7, 8]);+ * console.log(result); // prints "56"+ * ```+ *+ * A string can also be passed in instead of a function.+ *+ * ```js+ * console.log(await frame.evaluate('1 + 2')); // prints "3"+ * ```+ *+ * [ElementHandle](https://playwright.dev/docs/api/class-elementhandle) instances can be passed as an argument to the+ * [frame.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate):+ *+ * ```js+ * const bodyHandle = await frame.evaluate('document.body');+ * const html = await frame.evaluate(([body, suffix]) =>+ * body.innerHTML + suffix, [bodyHandle, 'hello'],+ * );+ * await bodyHandle.dispose();+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-option-expression).+ */+ evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg): Promise<R>;+ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-option-expression).+ *+ * If the function passed to the+ * [frame.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate) returns a+ * [Promise], then [frame.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate)+ * would wait for the promise to resolve and return its value.+ *+ * If the function passed to the+ * [frame.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate) returns a+ * non-[Serializable] value, then+ * [frame.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate) returns+ * `undefined`. Playwright also supports transferring some additional values that are not serializable by `JSON`:+ * `-0`, `NaN`, `Infinity`, `-Infinity`.+ *+ * **Usage**+ *+ * ```js+ * const result = await frame.evaluate(([x, y]) => {+ * return Promise.resolve(x * y);+ * }, [7, 8]);+ * console.log(result); // prints "56"+ * ```+ *+ * A string can also be passed in instead of a function.+ *+ * ```js+ * console.log(await frame.evaluate('1 + 2')); // prints "3"+ * ```+ *+ * [ElementHandle](https://playwright.dev/docs/api/class-elementhandle) instances can be passed as an argument to the+ * [frame.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate):+ *+ * ```js+ * const bodyHandle = await frame.evaluate('document.body');+ * const html = await frame.evaluate(([body, suffix]) =>+ * body.innerHTML + suffix, [bodyHandle, 'hello'],+ * );+ * await bodyHandle.dispose();+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-option-expression).+ */+ evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any): Promise<R>;++ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle-option-expression) as a+ * [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * The only difference between+ * [frame.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate) and+ * [frame.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle) is+ * that [frame.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle)+ * returns [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * If the function, passed to the+ * [frame.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle),+ * returns a [Promise], then+ * [frame.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * // Handle for the window object+ * const aWindowHandle = await frame.evaluateHandle(() => Promise.resolve(window));+ * ```+ *+ * A string can also be passed in instead of a function.+ *+ * ```js+ * const aHandle = await frame.evaluateHandle('document'); // Handle for the 'document'.+ * ```+ *+ * [JSHandle](https://playwright.dev/docs/api/class-jshandle) instances can be passed as an argument to the+ * [frame.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle):+ *+ * ```js+ * const aHandle = await frame.evaluateHandle(() => document.body);+ * const resultHandle = await frame.evaluateHandle(([body, suffix]) =>+ * body.innerHTML + suffix, [aHandle, 'hello'],+ * );+ * console.log(await resultHandle.jsonValue());+ * await resultHandle.dispose();+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle-option-expression).+ */+ evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg): Promise<SmartHandle<R>>;+ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle-option-expression) as a+ * [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * The only difference between+ * [frame.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate) and+ * [frame.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle) is+ * that [frame.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle)+ * returns [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * If the function, passed to the+ * [frame.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle),+ * returns a [Promise], then+ * [frame.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * // Handle for the window object+ * const aWindowHandle = await frame.evaluateHandle(() => Promise.resolve(window));+ * ```+ *+ * A string can also be passed in instead of a function.+ *+ * ```js+ * const aHandle = await frame.evaluateHandle('document'); // Handle for the 'document'.+ * ```+ *+ * [JSHandle](https://playwright.dev/docs/api/class-jshandle) instances can be passed as an argument to the+ * [frame.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle):+ *+ * ```js+ * const aHandle = await frame.evaluateHandle(() => document.body);+ * const resultHandle = await frame.evaluateHandle(([body, suffix]) =>+ * body.innerHTML + suffix, [aHandle, 'hello'],+ * );+ * console.log(await resultHandle.jsonValue());+ * await resultHandle.dispose();+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle-option-expression).+ */+ evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any): Promise<SmartHandle<R>>;++ /**+ * **NOTE** Use locator-based [frame.locator(selector[, options])](https://playwright.dev/docs/api/class-frame#frame-locator)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns the ElementHandle pointing to the frame element.+ *+ * **NOTE** The use of [ElementHandle](https://playwright.dev/docs/api/class-elementhandle) is discouraged, use+ * [Locator](https://playwright.dev/docs/api/class-locator) objects and web-first assertions instead.+ *+ * The method finds an element matching the specified selector within the frame. If no elements match the selector,+ * returns `null`.+ * @param selector A selector to query for.+ * @param options+ */+ $<K extends keyof HTMLElementTagNameMap>(selector: K, options?: { strict: boolean }): Promise<ElementHandleForTag<K> | null>;+ /**+ * **NOTE** Use locator-based [frame.locator(selector[, options])](https://playwright.dev/docs/api/class-frame#frame-locator)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns the ElementHandle pointing to the frame element.+ *+ * **NOTE** The use of [ElementHandle](https://playwright.dev/docs/api/class-elementhandle) is discouraged, use+ * [Locator](https://playwright.dev/docs/api/class-locator) objects and web-first assertions instead.+ *+ * The method finds an element matching the specified selector within the frame. If no elements match the selector,+ * returns `null`.+ * @param selector A selector to query for.+ * @param options+ */+ $(selector: string, options?: { strict: boolean }): Promise<ElementHandle<SVGElement | HTMLElement> | null>;++ /**+ * **NOTE** Use locator-based [frame.locator(selector[, options])](https://playwright.dev/docs/api/class-frame#frame-locator)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns the ElementHandles pointing to the frame elements.+ *+ * **NOTE** The use of [ElementHandle](https://playwright.dev/docs/api/class-elementhandle) is discouraged, use+ * [Locator](https://playwright.dev/docs/api/class-locator) objects instead.+ *+ * The method finds all elements matching the specified selector within the frame. If no elements match the selector,+ * returns empty array.+ * @param selector A selector to query for.+ */+ $$<K extends keyof HTMLElementTagNameMap>(selector: K): Promise<ElementHandleForTag<K>[]>;+ /**+ * **NOTE** Use locator-based [frame.locator(selector[, options])](https://playwright.dev/docs/api/class-frame#frame-locator)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns the ElementHandles pointing to the frame elements.+ *+ * **NOTE** The use of [ElementHandle](https://playwright.dev/docs/api/class-elementhandle) is discouraged, use+ * [Locator](https://playwright.dev/docs/api/class-locator) objects instead.+ *+ * The method finds all elements matching the specified selector within the frame. If no elements match the selector,+ * returns empty array.+ * @param selector A selector to query for.+ */+ $$(selector: string): Promise<ElementHandle<SVGElement | HTMLElement>[]>;++ /**+ * **NOTE** This method does not wait for the element to pass the actionability checks and therefore can lead to the flaky+ * tests. Use+ * [locator.evaluate(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods or web-first assertions instead.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression).+ *+ * The method finds an element matching the specified selector within the frame and passes it as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression). If no+ * elements match the selector, the method throws an error.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression) returns a+ * [Promise], then+ * [frame.$eval(selector, pageFunction[, arg, options])](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const searchValue = await frame.$eval('#search', el => el.value);+ * const preloadHref = await frame.$eval('link[rel=preload]', el => el.href);+ * const html = await frame.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression).+ * @param options+ */+ $eval<K extends keyof HTMLElementTagNameMap, R, Arg>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K], Arg, R>, arg: Arg): Promise<R>;+ /**+ * **NOTE** This method does not wait for the element to pass the actionability checks and therefore can lead to the flaky+ * tests. Use+ * [locator.evaluate(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods or web-first assertions instead.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression).+ *+ * The method finds an element matching the specified selector within the frame and passes it as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression). If no+ * elements match the selector, the method throws an error.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression) returns a+ * [Promise], then+ * [frame.$eval(selector, pageFunction[, arg, options])](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const searchValue = await frame.$eval('#search', el => el.value);+ * const preloadHref = await frame.$eval('link[rel=preload]', el => el.href);+ * const html = await frame.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression).+ * @param options+ */+ $eval<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E, Arg, R>, arg: Arg): Promise<R>;+ /**+ * **NOTE** This method does not wait for the element to pass the actionability checks and therefore can lead to the flaky+ * tests. Use+ * [locator.evaluate(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods or web-first assertions instead.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression).+ *+ * The method finds an element matching the specified selector within the frame and passes it as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression). If no+ * elements match the selector, the method throws an error.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression) returns a+ * [Promise], then+ * [frame.$eval(selector, pageFunction[, arg, options])](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const searchValue = await frame.$eval('#search', el => el.value);+ * const preloadHref = await frame.$eval('link[rel=preload]', el => el.href);+ * const html = await frame.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression).+ * @param options+ */+ $eval<K extends keyof HTMLElementTagNameMap, R>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K], void, R>, arg?: any): Promise<R>;+ /**+ * **NOTE** This method does not wait for the element to pass the actionability checks and therefore can lead to the flaky+ * tests. Use+ * [locator.evaluate(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods or web-first assertions instead.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression).+ *+ * The method finds an element matching the specified selector within the frame and passes it as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression). If no+ * elements match the selector, the method throws an error.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression) returns a+ * [Promise], then+ * [frame.$eval(selector, pageFunction[, arg, options])](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const searchValue = await frame.$eval('#search', el => el.value);+ * const preloadHref = await frame.$eval('link[rel=preload]', el => el.href);+ * const html = await frame.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-option-expression).+ * @param options+ */+ $eval<R, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E, void, R>, arg?: any): Promise<R>;++ /**+ * **NOTE** In most cases,+ * [locator.evaluateAll(pageFunction[, arg])](https://playwright.dev/docs/api/class-locator#locator-evaluate-all),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods and web-first assertions do a better+ * job.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression).+ *+ * The method finds all elements matching the specified selector within the frame and passes an array of matched+ * elements as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression).+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression)+ * returns a [Promise], then+ * [frame.$$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const divsCounts = await frame.$$eval('div', (divs, min) => divs.length >= min, 10);+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression).+ */+ $$eval<K extends keyof HTMLElementTagNameMap, R, Arg>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K][], Arg, R>, arg: Arg): Promise<R>;+ /**+ * **NOTE** In most cases,+ * [locator.evaluateAll(pageFunction[, arg])](https://playwright.dev/docs/api/class-locator#locator-evaluate-all),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods and web-first assertions do a better+ * job.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression).+ *+ * The method finds all elements matching the specified selector within the frame and passes an array of matched+ * elements as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression).+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression)+ * returns a [Promise], then+ * [frame.$$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const divsCounts = await frame.$$eval('div', (divs, min) => divs.length >= min, 10);+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression).+ */+ $$eval<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E[], Arg, R>, arg: Arg): Promise<R>;+ /**+ * **NOTE** In most cases,+ * [locator.evaluateAll(pageFunction[, arg])](https://playwright.dev/docs/api/class-locator#locator-evaluate-all),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods and web-first assertions do a better+ * job.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression).+ *+ * The method finds all elements matching the specified selector within the frame and passes an array of matched+ * elements as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression).+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression)+ * returns a [Promise], then+ * [frame.$$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const divsCounts = await frame.$$eval('div', (divs, min) => divs.length >= min, 10);+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression).+ */+ $$eval<K extends keyof HTMLElementTagNameMap, R>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K][], void, R>, arg?: any): Promise<R>;+ /**+ * **NOTE** In most cases,+ * [locator.evaluateAll(pageFunction[, arg])](https://playwright.dev/docs/api/class-locator#locator-evaluate-all),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods and web-first assertions do a better+ * job.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression).+ *+ * The method finds all elements matching the specified selector within the frame and passes an array of matched+ * elements as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression).+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression)+ * returns a [Promise], then+ * [frame.$$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const divsCounts = await frame.$$eval('div', (divs, min) => divs.length >= min, 10);+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all-option-expression).+ */+ $$eval<R, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E[], void, R>, arg?: any): Promise<R>;++ /**+ * Returns when the+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-wait-for-function-option-expression) returns a+ * truthy value, returns that value.+ *+ * **Usage**+ *+ * The+ * [frame.waitForFunction(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-frame#frame-wait-for-function)+ * can be used to observe viewport size change:+ *+ * ```js+ * const { firefox } = require('playwright'); // Or 'chromium' or 'webkit'.+ *+ * (async () => {+ * const browser = await firefox.launch();+ * const page = await browser.newPage();+ * const watchDog = page.mainFrame().waitForFunction('window.innerWidth < 100');+ * await page.setViewportSize({ width: 50, height: 50 });+ * await watchDog;+ * await browser.close();+ * })();+ * ```+ *+ * To pass an argument to the predicate of `frame.waitForFunction` function:+ *+ * ```js+ * const selector = '.foo';+ * await frame.waitForFunction(selector => !!document.querySelector(selector), selector);+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-wait-for-function-option-expression).+ * @param options+ */+ waitForFunction<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: PageWaitForFunctionOptions): Promise<SmartHandle<R>>;+ /**+ * Returns when the+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-wait-for-function-option-expression) returns a+ * truthy value, returns that value.+ *+ * **Usage**+ *+ * The+ * [frame.waitForFunction(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-frame#frame-wait-for-function)+ * can be used to observe viewport size change:+ *+ * ```js+ * const { firefox } = require('playwright'); // Or 'chromium' or 'webkit'.+ *+ * (async () => {+ * const browser = await firefox.launch();+ * const page = await browser.newPage();+ * const watchDog = page.mainFrame().waitForFunction('window.innerWidth < 100');+ * await page.setViewportSize({ width: 50, height: 50 });+ * await watchDog;+ * await browser.close();+ * })();+ * ```+ *+ * To pass an argument to the predicate of `frame.waitForFunction` function:+ *+ * ```js+ * const selector = '.foo';+ * await frame.waitForFunction(selector => !!document.querySelector(selector), selector);+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-wait-for-function-option-expression).+ * @param options+ */+ waitForFunction<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: PageWaitForFunctionOptions): Promise<SmartHandle<R>>;++ /**+ * **NOTE** Use web assertions that assert visibility or a locator-based+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for) instead. Read more+ * about [locators](https://playwright.dev/docs/locators).+ *+ * Returns when element specified by selector satisfies+ * [`state`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-state) option. Returns `null`+ * if waiting for `hidden` or `detached`.+ *+ * **NOTE** Playwright automatically waits for element to be ready before performing an action. Using+ * [Locator](https://playwright.dev/docs/api/class-locator) objects and web-first assertions make the code+ * wait-for-selector-free.+ *+ * Wait for the [`selector`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-selector) to+ * satisfy [`state`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-state) option (either+ * appear/disappear from dom, or become visible/hidden). If at the moment of calling the method+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-selector) already satisfies+ * the condition, the method will return immediately. If the selector doesn't satisfy the condition for the+ * [`timeout`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-timeout) milliseconds, the+ * function will throw.+ *+ * **Usage**+ *+ * This method works across navigations:+ *+ * ```js+ * const { chromium } = require('playwright'); // Or 'firefox' or 'webkit'.+ *+ * (async () => {+ * const browser = await chromium.launch();+ * const page = await browser.newPage();+ * for (const currentURL of ['https://google.com', 'https://bbc.com']) {+ * await page.goto(currentURL);+ * const element = await page.mainFrame().waitForSelector('img');+ * console.log('Loaded image: ' + await element.getAttribute('src'));+ * }+ * await browser.close();+ * })();+ * ```+ *+ * @param selector A selector to query for.+ * @param options+ */+ waitForSelector<K extends keyof HTMLElementTagNameMap>(selector: K, options?: PageWaitForSelectorOptionsNotHidden): Promise<ElementHandleForTag<K>>;+ /**+ * **NOTE** Use web assertions that assert visibility or a locator-based+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for) instead. Read more+ * about [locators](https://playwright.dev/docs/locators).+ *+ * Returns when element specified by selector satisfies+ * [`state`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-state) option. Returns `null`+ * if waiting for `hidden` or `detached`.+ *+ * **NOTE** Playwright automatically waits for element to be ready before performing an action. Using+ * [Locator](https://playwright.dev/docs/api/class-locator) objects and web-first assertions make the code+ * wait-for-selector-free.+ *+ * Wait for the [`selector`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-selector) to+ * satisfy [`state`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-state) option (either+ * appear/disappear from dom, or become visible/hidden). If at the moment of calling the method+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-selector) already satisfies+ * the condition, the method will return immediately. If the selector doesn't satisfy the condition for the+ * [`timeout`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-timeout) milliseconds, the+ * function will throw.+ *+ * **Usage**+ *+ * This method works across navigations:+ *+ * ```js+ * const { chromium } = require('playwright'); // Or 'firefox' or 'webkit'.+ *+ * (async () => {+ * const browser = await chromium.launch();+ * const page = await browser.newPage();+ * for (const currentURL of ['https://google.com', 'https://bbc.com']) {+ * await page.goto(currentURL);+ * const element = await page.mainFrame().waitForSelector('img');+ * console.log('Loaded image: ' + await element.getAttribute('src'));+ * }+ * await browser.close();+ * })();+ * ```+ *+ * @param selector A selector to query for.+ * @param options+ */+ waitForSelector(selector: string, options?: PageWaitForSelectorOptionsNotHidden): Promise<ElementHandle<SVGElement | HTMLElement>>;+ /**+ * **NOTE** Use web assertions that assert visibility or a locator-based+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for) instead. Read more+ * about [locators](https://playwright.dev/docs/locators).+ *+ * Returns when element specified by selector satisfies+ * [`state`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-state) option. Returns `null`+ * if waiting for `hidden` or `detached`.+ *+ * **NOTE** Playwright automatically waits for element to be ready before performing an action. Using+ * [Locator](https://playwright.dev/docs/api/class-locator) objects and web-first assertions make the code+ * wait-for-selector-free.+ *+ * Wait for the [`selector`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-selector) to+ * satisfy [`state`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-state) option (either+ * appear/disappear from dom, or become visible/hidden). If at the moment of calling the method+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-selector) already satisfies+ * the condition, the method will return immediately. If the selector doesn't satisfy the condition for the+ * [`timeout`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-timeout) milliseconds, the+ * function will throw.+ *+ * **Usage**+ *+ * This method works across navigations:+ *+ * ```js+ * const { chromium } = require('playwright'); // Or 'firefox' or 'webkit'.+ *+ * (async () => {+ * const browser = await chromium.launch();+ * const page = await browser.newPage();+ * for (const currentURL of ['https://google.com', 'https://bbc.com']) {+ * await page.goto(currentURL);+ * const element = await page.mainFrame().waitForSelector('img');+ * console.log('Loaded image: ' + await element.getAttribute('src'));+ * }+ * await browser.close();+ * })();+ * ```+ *+ * @param selector A selector to query for.+ * @param options+ */+ waitForSelector<K extends keyof HTMLElementTagNameMap>(selector: K, options: PageWaitForSelectorOptions): Promise<ElementHandleForTag<K> | null>;+ /**+ * **NOTE** Use web assertions that assert visibility or a locator-based+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for) instead. Read more+ * about [locators](https://playwright.dev/docs/locators).+ *+ * Returns when element specified by selector satisfies+ * [`state`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-state) option. Returns `null`+ * if waiting for `hidden` or `detached`.+ *+ * **NOTE** Playwright automatically waits for element to be ready before performing an action. Using+ * [Locator](https://playwright.dev/docs/api/class-locator) objects and web-first assertions make the code+ * wait-for-selector-free.+ *+ * Wait for the [`selector`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-selector) to+ * satisfy [`state`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-state) option (either+ * appear/disappear from dom, or become visible/hidden). If at the moment of calling the method+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-selector) already satisfies+ * the condition, the method will return immediately. If the selector doesn't satisfy the condition for the+ * [`timeout`](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector-option-timeout) milliseconds, the+ * function will throw.+ *+ * **Usage**+ *+ * This method works across navigations:+ *+ * ```js+ * const { chromium } = require('playwright'); // Or 'firefox' or 'webkit'.+ *+ * (async () => {+ * const browser = await chromium.launch();+ * const page = await browser.newPage();+ * for (const currentURL of ['https://google.com', 'https://bbc.com']) {+ * await page.goto(currentURL);+ * const element = await page.mainFrame().waitForSelector('img');+ * console.log('Loaded image: ' + await element.getAttribute('src'));+ * }+ * await browser.close();+ * })();+ * ```+ *+ * @param selector A selector to query for.+ * @param options+ */+ waitForSelector(selector: string, options: PageWaitForSelectorOptions): Promise<null|ElementHandle<SVGElement | HTMLElement>>;+ /**+ * Returns the added tag when the script's onload fires or when the script content was injected into frame.+ *+ * Adds a `<script>` tag into the page with the desired url or content.+ * @param options+ */+ addScriptTag(options?: {+ /**+ * Raw JavaScript content to be injected into frame.+ */+ content?: string;++ /**+ * Path to the JavaScript file to be injected into frame. If `path` is a relative path, then it is resolved relative+ * to the current working directory.+ */+ path?: string;++ /**+ * Script type. Use 'module' in order to load a JavaScript ES6 module. See+ * [script](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script) for more details.+ */+ type?: string;++ /**+ * URL of a script to be added.+ */+ url?: string;+ }): Promise<ElementHandle>;++ /**+ * Returns the added tag when the stylesheet's onload fires or when the CSS content was injected into frame.+ *+ * Adds a `<link rel="stylesheet">` tag into the page with the desired url or a `<style type="text/css">` tag with the+ * content.+ * @param options+ */+ addStyleTag(options?: {+ /**+ * Raw CSS content to be injected into frame.+ */+ content?: string;++ /**+ * Path to the CSS file to be injected into frame. If `path` is a relative path, then it is resolved relative to the+ * current working directory.+ */+ path?: string;++ /**+ * URL of the `<link>` tag.+ */+ url?: string;+ }): Promise<ElementHandle>;++ /**+ * **NOTE** Use locator-based [locator.check([options])](https://playwright.dev/docs/api/class-locator#locator-check) instead.+ * Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method checks an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-check-option-selector) by performing the following+ * steps:+ * 1. Find an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-check-option-selector). If there is none, wait+ * until a matching element is attached to the DOM.+ * 1. Ensure that matched element is a checkbox or a radio input. If not, this method throws. If the element is+ * already checked, this method returns immediately.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-frame#frame-check-option-force) option is set. If the element+ * is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element.+ * 1. Ensure that the element is now checked. If not, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-frame#frame-check-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ check(selector: string, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ childFrames(): Array<Frame>;++ /**+ * **NOTE** Use locator-based [locator.click([options])](https://playwright.dev/docs/api/class-locator#locator-click) instead.+ * Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method clicks an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-click-option-selector) by performing the following+ * steps:+ * 1. Find an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-click-option-selector). If there is none, wait+ * until a matching element is attached to the DOM.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-frame#frame-click-option-force) option is set. If the element+ * is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-frame#frame-click-option-position).+ * 1. Wait for initiated navigations to either succeed or fail, unless+ * [`noWaitAfter`](https://playwright.dev/docs/api/class-frame#frame-click-option-no-wait-after) option is set.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-frame#frame-click-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ click(selector: string, options?: {+ /**+ * Defaults to `left`.+ */+ button?: "left"|"right"|"middle";++ /**+ * defaults to 1. See [UIEvent.detail].+ */+ clickCount?: number;++ /**+ * Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You+ * can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as+ * navigating to inaccessible pages. Defaults to `false`.+ * @deprecated This option will default to `true` in the future.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard+ * `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys+ * are pressed.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * Gets the full HTML contents of the frame, including the doctype.+ */+ content(): Promise<string>;++ /**+ * **NOTE** Use locator-based [locator.dblclick([options])](https://playwright.dev/docs/api/class-locator#locator-dblclick)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method double clicks an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-dblclick-option-selector) by performing the+ * following steps:+ * 1. Find an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-dblclick-option-selector). If there is none,+ * wait until a matching element is attached to the DOM.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-frame#frame-dblclick-option-force) option is set. If the+ * element is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to double click in the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-frame#frame-dblclick-option-position). if the first click+ * of the `dblclick()` triggers a navigation event, this method will throw.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-frame#frame-dblclick-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ *+ * **NOTE** `frame.dblclick()` dispatches two `click` events and a single `dblclick` event.+ *+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ dblclick(selector: string, options?: {+ /**+ * Defaults to `left`.+ */+ button?: "left"|"right"|"middle";++ /**+ * Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard+ * `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys+ * are pressed.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based+ * [locator.dispatchEvent(type[, eventInit, options])](https://playwright.dev/docs/api/class-locator#locator-dispatch-event)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the element,+ * `click` is dispatched. This is equivalent to calling+ * [element.click()](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click).+ *+ * **Usage**+ *+ * ```js+ * await frame.dispatchEvent('button#submit', 'click');+ * ```+ *+ * Under the hood, it creates an instance of an event based on the given+ * [`type`](https://playwright.dev/docs/api/class-frame#frame-dispatch-event-option-type), initializes it with+ * [`eventInit`](https://playwright.dev/docs/api/class-frame#frame-dispatch-event-option-event-init) properties and+ * dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.+ *+ * Since [`eventInit`](https://playwright.dev/docs/api/class-frame#frame-dispatch-event-option-event-init) is+ * event-specific, please refer to the events documentation for the lists of initial properties:+ * - [DeviceMotionEvent](https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent/DeviceMotionEvent)+ * - [DeviceOrientationEvent](https://developer.mozilla.org/en-US/docs/Web/API/DeviceOrientationEvent/DeviceOrientationEvent)+ * - [DragEvent](https://developer.mozilla.org/en-US/docs/Web/API/DragEvent/DragEvent)+ * - [Event](https://developer.mozilla.org/en-US/docs/Web/API/Event/Event)+ * - [FocusEvent](https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent/FocusEvent)+ * - [KeyboardEvent](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/KeyboardEvent)+ * - [MouseEvent](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/MouseEvent)+ * - [PointerEvent](https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/PointerEvent)+ * - [TouchEvent](https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent/TouchEvent)+ * - [WheelEvent](https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/WheelEvent)+ *+ * You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:+ *+ * ```js+ * // Note you can only create DataTransfer in Chromium and Firefox+ * const dataTransfer = await frame.evaluateHandle(() => new DataTransfer());+ * await frame.dispatchEvent('#source', 'dragstart', { dataTransfer });+ * ```+ *+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param type DOM event type: `"click"`, `"dragstart"`, etc.+ * @param eventInit Optional event-specific initialization properties.+ * @param options+ */+ dispatchEvent(selector: string, type: string, eventInit?: EvaluationArgument, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * @param source A selector to search for an element to drag. If there are multiple elements satisfying the selector, the first will+ * be used.+ * @param target A selector to search for an element to drop onto. If there are multiple elements satisfying the selector, the first+ * will be used.+ * @param options+ */+ dragAndDrop(source: string, target: string, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * Clicks on the source element at this point relative to the top-left corner of the element's padding box. If not+ * specified, some visible point of the element is used.+ */+ sourcePosition?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Drops on the target element at this point relative to the top-left corner of the element's padding box. If not+ * specified, some visible point of the element is used.+ */+ targetPosition?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.fill(value[, options])](https://playwright.dev/docs/api/class-locator#locator-fill)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method waits for an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-fill-option-selector), waits for+ * [actionability](https://playwright.dev/docs/actionability) checks, focuses the element, fills it and triggers an `input` event after+ * filling. Note that you can pass an empty string to clear the input field.+ *+ * If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an+ * error. However, if the element is inside the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled+ * instead.+ *+ * To send fine-grained keyboard events, use+ * [locator.pressSequentially(text[, options])](https://playwright.dev/docs/api/class-locator#locator-press-sequentially).+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param value Value to fill for the `<input>`, `<textarea>` or `[contenteditable]` element.+ * @param options+ */+ fill(selector: string, value: string, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.focus([options])](https://playwright.dev/docs/api/class-locator#locator-focus) instead.+ * Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method fetches an element with+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-focus-option-selector) and focuses it. If there's no+ * element matching [`selector`](https://playwright.dev/docs/api/class-frame#frame-focus-option-selector), the method+ * waits until a matching element appears in the DOM.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ focus(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Returns the `frame` or `iframe` element handle which corresponds to this frame.+ *+ * This is an inverse of+ * [elementHandle.contentFrame()](https://playwright.dev/docs/api/class-elementhandle#element-handle-content-frame).+ * Note that returned handle actually belongs to the parent frame.+ *+ * This method throws an error if the frame has been detached before `frameElement()` returns.+ *+ * **Usage**+ *+ * ```js+ * const frameElement = await frame.frameElement();+ * const contentFrame = await frameElement.contentFrame();+ * console.log(frame === contentFrame); // -> true+ * ```+ *+ */+ frameElement(): Promise<ElementHandle>;++ /**+ * When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements+ * in that iframe.+ *+ * **Usage**+ *+ * Following snippet locates element with text "Submit" in the iframe with id `my-frame`, like `<iframe+ * id="my-frame">`:+ *+ * ```js+ * const locator = frame.frameLocator('#my-iframe').getByText('Submit');+ * await locator.click();+ * ```+ *+ * @param selector A selector to use when resolving DOM element.+ */+ frameLocator(selector: string): FrameLocator;++ /**+ * **NOTE** Use locator-based+ * [locator.getAttribute(name[, options])](https://playwright.dev/docs/api/class-locator#locator-get-attribute)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns element attribute value.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param name Attribute name to get the value for.+ * @param options+ */+ getAttribute(selector: string, name: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<null|string>;++ /**+ * Allows locating elements by their alt text.+ *+ * **Usage**+ *+ * For example, this method will find the image by alt text "Playwright logo":+ *+ * ```html+ * <img alt='Playwright logo'>+ * ```+ *+ * ```js+ * await page.getByAltText('Playwright logo').click();+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByAltText(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating input elements by the text of the associated `<label>` or `aria-labelledby` element, or by the+ * `aria-label` attribute.+ *+ * **Usage**+ *+ * For example, this method will find inputs by label "Username" and "Password" in the following DOM:+ *+ * ```html+ * <input aria-label="Username">+ * <label for="password-input">Password:</label>+ * <input id="password-input">+ * ```+ *+ * ```js+ * await page.getByLabel('Username').fill('john');+ * await page.getByLabel('Password').fill('secret');+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByLabel(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating input elements by the placeholder text.+ *+ * **Usage**+ *+ * For example, consider the following DOM structure.+ *+ * ```html+ * <input type="email" placeholder="[email protected]" />+ * ```+ *+ * You can fill the input after locating it by the placeholder text:+ *+ * ```js+ * await page+ * .getByPlaceholder('[email protected]')+ * .fill('[email protected]');+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByPlaceholder(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating elements by their [ARIA role](https://www.w3.org/TR/wai-aria-1.2/#roles),+ * [ARIA attributes](https://www.w3.org/TR/wai-aria-1.2/#aria-attributes) and+ * [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).+ *+ * **Usage**+ *+ * Consider the following DOM structure.+ *+ * ```html+ * <h3>Sign up</h3>+ * <label>+ * <input type="checkbox" /> Subscribe+ * </label>+ * <br/>+ * <button>Submit</button>+ * ```+ *+ * You can locate each element by it's implicit role:+ *+ * ```js+ * await expect(page.getByRole('heading', { name: 'Sign up' })).toBeVisible();+ *+ * await page.getByRole('checkbox', { name: 'Subscribe' }).check();+ *+ * await page.getByRole('button', { name: /submit/i }).click();+ * ```+ *+ * **Details**+ *+ * Role selector **does not replace** accessibility audits and conformance tests, but rather gives early feedback+ * about the ARIA guidelines.+ *+ * Many html elements have an implicitly [defined role](https://w3c.github.io/html-aam/#html-element-role-mappings)+ * that is recognized by the role selector. You can find all the+ * [supported roles here](https://www.w3.org/TR/wai-aria-1.2/#role_definitions). ARIA guidelines **do not recommend**+ * duplicating implicit roles and attributes by setting `role` and/or `aria-*` attributes to default values.+ * @param role Required aria role.+ * @param options+ */+ getByRole(role: "alert"|"alertdialog"|"application"|"article"|"banner"|"blockquote"|"button"|"caption"|"cell"|"checkbox"|"code"|"columnheader"|"combobox"|"complementary"|"contentinfo"|"definition"|"deletion"|"dialog"|"directory"|"document"|"emphasis"|"feed"|"figure"|"form"|"generic"|"grid"|"gridcell"|"group"|"heading"|"img"|"insertion"|"link"|"list"|"listbox"|"listitem"|"log"|"main"|"marquee"|"math"|"meter"|"menu"|"menubar"|"menuitem"|"menuitemcheckbox"|"menuitemradio"|"navigation"|"none"|"note"|"option"|"paragraph"|"presentation"|"progressbar"|"radio"|"radiogroup"|"region"|"row"|"rowgroup"|"rowheader"|"scrollbar"|"search"|"searchbox"|"separator"|"slider"|"spinbutton"|"status"|"strong"|"subscript"|"superscript"|"switch"|"tab"|"table"|"tablist"|"tabpanel"|"term"|"textbox"|"time"|"timer"|"toolbar"|"tooltip"|"tree"|"treegrid"|"treeitem", options?: {+ /**+ * An attribute that is usually set by `aria-checked` or native `<input type=checkbox>` controls.+ *+ * Learn more about [`aria-checked`](https://www.w3.org/TR/wai-aria-1.2/#aria-checked).+ */+ checked?: boolean;++ /**+ * An attribute that is usually set by `aria-disabled` or `disabled`.+ *+ * **NOTE** Unlike most other attributes, `disabled` is inherited through the DOM hierarchy. Learn more about+ * [`aria-disabled`](https://www.w3.org/TR/wai-aria-1.2/#aria-disabled).+ *+ */+ disabled?: boolean;++ /**+ * Whether [`name`](https://playwright.dev/docs/api/class-frame#frame-get-by-role-option-name) is matched exactly:+ * case-sensitive and whole-string. Defaults to false. Ignored when+ * [`name`](https://playwright.dev/docs/api/class-frame#frame-get-by-role-option-name) is a regular expression. Note+ * that exact match still trims whitespace.+ */+ exact?: boolean;++ /**+ * An attribute that is usually set by `aria-expanded`.+ *+ * Learn more about [`aria-expanded`](https://www.w3.org/TR/wai-aria-1.2/#aria-expanded).+ */+ expanded?: boolean;++ /**+ * Option that controls whether hidden elements are matched. By default, only non-hidden elements, as+ * [defined by ARIA](https://www.w3.org/TR/wai-aria-1.2/#tree_exclusion), are matched by role selector.+ *+ * Learn more about [`aria-hidden`](https://www.w3.org/TR/wai-aria-1.2/#aria-hidden).+ */+ includeHidden?: boolean;++ /**+ * A number attribute that is usually present for roles `heading`, `listitem`, `row`, `treeitem`, with default values+ * for `<h1>-<h6>` elements.+ *+ * Learn more about [`aria-level`](https://www.w3.org/TR/wai-aria-1.2/#aria-level).+ */+ level?: number;++ /**+ * Option to match the [accessible name](https://w3c.github.io/accname/#dfn-accessible-name). By default, matching is+ * case-insensitive and searches for a substring, use+ * [`exact`](https://playwright.dev/docs/api/class-frame#frame-get-by-role-option-exact) to control this behavior.+ *+ * Learn more about [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).+ */+ name?: string|RegExp;++ /**+ * An attribute that is usually set by `aria-pressed`.+ *+ * Learn more about [`aria-pressed`](https://www.w3.org/TR/wai-aria-1.2/#aria-pressed).+ */+ pressed?: boolean;++ /**+ * An attribute that is usually set by `aria-selected`.+ *+ * Learn more about [`aria-selected`](https://www.w3.org/TR/wai-aria-1.2/#aria-selected).+ */+ selected?: boolean;+ }): Locator;++ /**+ * Locate element by the test id.+ *+ * **Usage**+ *+ * Consider the following DOM structure.+ *+ * ```html+ * <button data-testid="directions">Itinéraire</button>+ * ```+ *+ * You can locate the element by it's test id:+ *+ * ```js+ * await page.getByTestId('directions').click();+ * ```+ *+ * **Details**+ *+ * By default, the `data-testid` attribute is used as a test id. Use+ * [selectors.setTestIdAttribute(attributeName)](https://playwright.dev/docs/api/class-selectors#selectors-set-test-id-attribute)+ * to configure a different test id attribute if necessary.+ *+ * ```js+ * // Set custom test id attribute from @playwright/test config:+ * import { defineConfig } from '@playwright/test';+ *+ * export default defineConfig({+ * use: {+ * testIdAttribute: 'data-pw'+ * },+ * });+ * ```+ *+ * @param testId Id to locate the element by.+ */+ getByTestId(testId: string|RegExp): Locator;++ /**+ * Allows locating elements that contain given text.+ *+ * See also [locator.filter([options])](https://playwright.dev/docs/api/class-locator#locator-filter) that allows to+ * match by another criteria, like an accessible role, and then filter by the text content.+ *+ * **Usage**+ *+ * Consider the following DOM structure:+ *+ * ```html+ * <div>Hello <span>world</span></div>+ * <div>Hello</div>+ * ```+ *+ * You can locate by text substring, exact string, or a regular expression:+ *+ * ```js+ * // Matches <span>+ * page.getByText('world');+ *+ * // Matches first <div>+ * page.getByText('Hello world');+ *+ * // Matches second <div>+ * page.getByText('Hello', { exact: true });+ *+ * // Matches both <div>s+ * page.getByText(/Hello/);+ *+ * // Matches second <div>+ * page.getByText(/^hello$/i);+ * ```+ *+ * **Details**+ *+ * Matching by text always normalizes whitespace, even with exact match. For example, it turns multiple spaces into+ * one, turns line breaks into spaces and ignores leading and trailing whitespace.+ *+ * Input elements of the type `button` and `submit` are matched by their `value` instead of the text content. For+ * example, locating by text `"Log in"` matches `<input type=button value="Log in">`.+ * @param text Text to locate the element for.+ * @param options+ */+ getByText(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating elements by their title attribute.+ *+ * **Usage**+ *+ * Consider the following DOM structure.+ *+ * ```html+ * <span title='Issues count'>25 issues</span>+ * ```+ *+ * You can check the issues count after locating it by the title text:+ *+ * ```js+ * await expect(page.getByTitle('Issues count')).toHaveText('25 issues');+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByTitle(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of+ * the last redirect.+ *+ * The method will throw an error if:+ * - there's an SSL error (e.g. in case of self-signed certificates).+ * - target URL is invalid.+ * - the [`timeout`](https://playwright.dev/docs/api/class-frame#frame-goto-option-timeout) is exceeded during+ * navigation.+ * - the remote server does not respond or is unreachable.+ * - the main resource failed to load.+ *+ * The method will not throw an error when any valid HTTP status code is returned by the remote server, including 404+ * "Not Found" and 500 "Internal Server Error". The status code for such responses can be retrieved by calling+ * [response.status()](https://playwright.dev/docs/api/class-response#response-status).+ *+ * **NOTE** The method either throws an error or returns a main resource response. The only exceptions are navigation+ * to `about:blank` or navigation to the same URL with a different hash, which would succeed and return `null`.+ *+ * **NOTE** Headless mode doesn't support navigation to a PDF document. See the+ * [upstream issue](https://bugs.chromium.org/p/chromium/issues/detail?id=761295).+ *+ * @param url URL to navigate frame to. The url should include scheme, e.g. `https://`.+ * @param options+ */+ goto(url: string, options?: {+ /**+ * Referer header value. If provided it will take preference over the referer header value set by+ * [page.setExtraHTTPHeaders(headers)](https://playwright.dev/docs/api/class-page#page-set-extra-http-headers).+ */+ referer?: string;++ /**+ * Maximum operation time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via+ * `navigationTimeout` option in the config, or by using the+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout),+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout),+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When to consider operation succeeded, defaults to `load`. Events can be either:+ * - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.+ * - `'load'` - consider operation to be finished when the `load` event is fired.+ * - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for+ * at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.+ * - `'commit'` - consider operation to be finished when network response is received and the document started+ * loading.+ */+ waitUntil?: "load"|"domcontentloaded"|"networkidle"|"commit";+ }): Promise<null|Response>;++ /**+ * **NOTE** Use locator-based [locator.hover([options])](https://playwright.dev/docs/api/class-locator#locator-hover) instead.+ * Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method hovers over an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-hover-option-selector) by performing the following+ * steps:+ * 1. Find an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-hover-option-selector). If there is none, wait+ * until a matching element is attached to the DOM.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-frame#frame-hover-option-force) option is set. If the element+ * is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to hover over the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-frame#frame-hover-option-position).+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-frame#frame-hover-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ hover(selector: string, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard+ * `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys+ * are pressed.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.innerHTML([options])](https://playwright.dev/docs/api/class-locator#locator-inner-html)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns `element.innerHTML`.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ innerHTML(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<string>;++ /**+ * **NOTE** Use locator-based [locator.innerText([options])](https://playwright.dev/docs/api/class-locator#locator-inner-text)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns `element.innerText`.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ innerText(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<string>;++ /**+ * **NOTE** Use locator-based+ * [locator.inputValue([options])](https://playwright.dev/docs/api/class-locator#locator-input-value) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns `input.value` for the selected `<input>` or `<textarea>` or `<select>` element.+ *+ * Throws for non-input elements. However, if the element is inside the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), returns the value of the+ * control.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ inputValue(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<string>;++ /**+ * **NOTE** Use locator-based [locator.isChecked([options])](https://playwright.dev/docs/api/class-locator#locator-is-checked)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is checked. Throws if the element is not a checkbox or radio input.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ isChecked(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * Returns `true` if the frame has been detached, or `false` otherwise.+ */+ isDetached(): boolean;++ /**+ * **NOTE** Use locator-based+ * [locator.isDisabled([options])](https://playwright.dev/docs/api/class-locator#locator-is-disabled) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/docs/actionability#enabled).+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ isDisabled(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * **NOTE** Use locator-based+ * [locator.isEditable([options])](https://playwright.dev/docs/api/class-locator#locator-is-editable) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is [editable](https://playwright.dev/docs/actionability#editable).+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ isEditable(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * Returns whether the element is [enabled](https://playwright.dev/docs/actionability#enabled).+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ isEnabled(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * **NOTE** Use locator-based [locator.isHidden([options])](https://playwright.dev/docs/api/class-locator#locator-is-hidden)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/docs/actionability#visible).+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-is-hidden-option-selector) that does not match any+ * elements is considered hidden.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ isHidden(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * @deprecated This option is ignored.+ * [frame.isHidden(selector[, options])](https://playwright.dev/docs/api/class-frame#frame-is-hidden) does not wait+ * for the element to become hidden and returns immediately.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * **NOTE** Use locator-based [locator.isVisible([options])](https://playwright.dev/docs/api/class-locator#locator-is-visible)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is [visible](https://playwright.dev/docs/actionability#visible).+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-is-visible-option-selector) that does not match any+ * elements is considered not visible.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ isVisible(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * @deprecated This option is ignored.+ * [frame.isVisible(selector[, options])](https://playwright.dev/docs/api/class-frame#frame-is-visible) does not wait+ * for the element to become visible and returns immediately.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * The method returns an element locator that can be used to perform actions on this page / frame. Locator is resolved+ * to the element immediately before performing an action, so a series of actions on the same locator can in fact be+ * performed on different DOM elements. That would happen if the DOM structure between those actions has changed.+ *+ * [Learn more about locators](https://playwright.dev/docs/locators).+ *+ * [Learn more about locators](https://playwright.dev/docs/locators).+ * @param selector A selector to use when resolving DOM element.+ * @param options+ */+ locator(selector: string, options?: {+ /**+ * Narrows down the results of the method to those which contain elements matching this relative locator. For example,+ * `article` that has `text=Playwright` matches `<article><div>Playwright</div></article>`.+ *+ * Inner locator **must be relative** to the outer locator and is queried starting with the outer locator match, not+ * the document root. For example, you can find `content` that has `div` in+ * `<article><content><div>Playwright</div></content></article>`. However, looking for `content` that has `article+ * div` will fail, because the inner locator must be relative and should not use any elements outside the `content`.+ *+ * Note that outer and inner locators must belong to the same frame. Inner locator must not contain+ * [FrameLocator](https://playwright.dev/docs/api/class-framelocator)s.+ */+ has?: Locator;++ /**+ * Matches elements that do not contain an element that matches an inner locator. Inner locator is queried against the+ * outer one. For example, `article` that does not have `div` matches `<article><span>Playwright</span></article>`.+ *+ * Note that outer and inner locators must belong to the same frame. Inner locator must not contain+ * [FrameLocator](https://playwright.dev/docs/api/class-framelocator)s.+ */+ hasNot?: Locator;++ /**+ * Matches elements that do not contain specified text somewhere inside, possibly in a child or a descendant element.+ * When passed a [string], matching is case-insensitive and searches for a substring.+ */+ hasNotText?: string|RegExp;++ /**+ * Matches elements containing specified text somewhere inside, possibly in a child or a descendant element. When+ * passed a [string], matching is case-insensitive and searches for a substring. For example, `"Playwright"` matches+ * `<article><div>Playwright</div></article>`.+ */+ hasText?: string|RegExp;+ }): Locator;++ /**+ * Returns frame's name attribute as specified in the tag.+ *+ * If the name is empty, returns the id attribute instead.+ *+ * **NOTE** This value is calculated once when the frame is created, and will not update if the attribute is changed+ * later.+ *+ */+ name(): string;++ /**+ * Returns the page containing this frame.+ */+ page(): Page;++ /**+ * Parent frame, if any. Detached frames and main frames return `null`.+ */+ parentFrame(): null|Frame;++ /**+ * **NOTE** Use locator-based [locator.press(key[, options])](https://playwright.dev/docs/api/class-locator#locator-press)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * [`key`](https://playwright.dev/docs/api/class-frame#frame-press-option-key) can specify the intended+ * [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) value or a single character+ * to generate the text for. A superset of the+ * [`key`](https://playwright.dev/docs/api/class-frame#frame-press-option-key) values can be found+ * [here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:+ *+ * `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`,+ * `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,+ * etc.+ *+ * Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,+ * `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.+ *+ * Holding down `Shift` will type the text that corresponds to the+ * [`key`](https://playwright.dev/docs/api/class-frame#frame-press-option-key) in the upper case.+ *+ * If [`key`](https://playwright.dev/docs/api/class-frame#frame-press-option-key) is a single character, it is+ * case-sensitive, so the values `a` and `A` will generate different respective texts.+ *+ * Shortcuts such as `key: "Control+o"`, `key: "Control++` or `key: "Control+Shift+T"` are supported as well. When+ * specified with the modifier, modifier is pressed and being held while the subsequent key is being pressed.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param key Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.+ * @param options+ */+ press(selector: string, key: string, options?: {+ /**+ * Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You+ * can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as+ * navigating to inaccessible pages. Defaults to `false`.+ * @deprecated This option will default to `true` in the future.+ */+ noWaitAfter?: boolean;++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based+ * [locator.selectOption(values[, options])](https://playwright.dev/docs/api/class-locator#locator-select-option)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method waits for an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-select-option-option-selector), waits for+ * [actionability](https://playwright.dev/docs/actionability) checks, waits until all specified options are present in the `<select>`+ * element and selects these options.+ *+ * If the target element is not a `<select>` element, this method throws an error. However, if the element is inside+ * the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be used+ * instead.+ *+ * Returns the array of option values that have been successfully selected.+ *+ * Triggers a `change` and `input` event once all the provided options have been selected.+ *+ * **Usage**+ *+ * ```js+ * // Single selection matching the value or label+ * frame.selectOption('select#colors', 'blue');+ *+ * // single selection matching both the value and the label+ * frame.selectOption('select#colors', { label: 'Blue' });+ *+ * // multiple selection+ * frame.selectOption('select#colors', 'red', 'green', 'blue');+ * ```+ *+ * @param selector A selector to query for.+ * @param values Options to select. If the `<select>` has the `multiple` attribute, all matching options are selected, otherwise+ * only the first option matching one of the passed options is selected. String values are matching both values and+ * labels. Option is considered matching if all specified properties match.+ * @param options+ */+ selectOption(selector: string, values: null|string|ElementHandle|ReadonlyArray<string>|{+ /**+ * Matches by `option.value`. Optional.+ */+ value?: string;++ /**+ * Matches by `option.label`. Optional.+ */+ label?: string;++ /**+ * Matches by the index. Optional.+ */+ index?: number;+ }|ReadonlyArray<ElementHandle>|ReadonlyArray<{+ /**+ * Matches by `option.value`. Optional.+ */+ value?: string;++ /**+ * Matches by `option.label`. Optional.+ */+ label?: string;++ /**+ * Matches by the index. Optional.+ */+ index?: number;+ }>, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<Array<string>>;++ /**+ * **NOTE** Use locator-based+ * [locator.setChecked(checked[, options])](https://playwright.dev/docs/api/class-locator#locator-set-checked)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method checks or unchecks an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-set-checked-option-selector) by performing the+ * following steps:+ * 1. Find an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-set-checked-option-selector). If there is+ * none, wait until a matching element is attached to the DOM.+ * 1. Ensure that matched element is a checkbox or a radio input. If not, this method throws.+ * 1. If the element already has the right checked state, this method returns immediately.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-frame#frame-set-checked-option-force) option is set. If the+ * element is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element.+ * 1. Ensure that the element is now checked or unchecked. If not, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-frame#frame-set-checked-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param checked Whether to check or uncheck the checkbox.+ * @param options+ */+ setChecked(selector: string, checked: boolean, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * This method internally calls [document.write()](https://developer.mozilla.org/en-US/docs/Web/API/Document/write),+ * inheriting all its specific characteristics and behaviors.+ * @param html HTML markup to assign to the page.+ * @param options+ */+ setContent(html: string, options?: {+ /**+ * Maximum operation time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via+ * `navigationTimeout` option in the config, or by using the+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout),+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout),+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When to consider operation succeeded, defaults to `load`. Events can be either:+ * - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.+ * - `'load'` - consider operation to be finished when the `load` event is fired.+ * - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for+ * at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.+ * - `'commit'` - consider operation to be finished when network response is received and the document started+ * loading.+ */+ waitUntil?: "load"|"domcontentloaded"|"networkidle"|"commit";+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based+ * [locator.setInputFiles(files[, options])](https://playwright.dev/docs/api/class-locator#locator-set-input-files)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Sets the value of the file input to these file paths or files. If some of the `filePaths` are relative paths, then+ * they are resolved relative to the current working directory. For empty array, clears the selected files.+ *+ * This method expects [`selector`](https://playwright.dev/docs/api/class-frame#frame-set-input-files-option-selector)+ * to point to an [input element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input). However, if the+ * element is inside the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), targets the control instead.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param files+ * @param options+ */+ setInputFiles(selector: string, files: string|ReadonlyArray<string>|{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }|ReadonlyArray<{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }>, options?: {+ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.tap([options])](https://playwright.dev/docs/api/class-locator#locator-tap) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * This method taps an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-tap-option-selector) by performing the following+ * steps:+ * 1. Find an element matching [`selector`](https://playwright.dev/docs/api/class-frame#frame-tap-option-selector).+ * If there is none, wait until a matching element is attached to the DOM.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-frame#frame-tap-option-force) option is set. If the element+ * is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.touchscreen](https://playwright.dev/docs/api/class-page#page-touchscreen) to tap the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-frame#frame-tap-option-position).+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-frame#frame-tap-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ *+ * **NOTE** `frame.tap()` requires that the `hasTouch` option of the browser context be set to true.+ *+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ tap(selector: string, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard+ * `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys+ * are pressed.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based+ * [locator.textContent([options])](https://playwright.dev/docs/api/class-locator#locator-text-content) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns `element.textContent`.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ textContent(selector: string, options?: {+ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<null|string>;++ /**+ * Returns the page title.+ */+ title(): Promise<string>;++ /**+ * Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text. `frame.type` can be used+ * to send fine-grained keyboard events. To fill values in form fields, use+ * [frame.fill(selector, value[, options])](https://playwright.dev/docs/api/class-frame#frame-fill).+ *+ * To press a special key, like `Control` or `ArrowDown`, use+ * [keyboard.press(key[, options])](https://playwright.dev/docs/api/class-keyboard#keyboard-press).+ *+ * **Usage**+ * @deprecated In most cases, you should use+ * [locator.fill(value[, options])](https://playwright.dev/docs/api/class-locator#locator-fill) instead. You only need+ * to press keys one by one if there is special keyboard handling on the page - in this case use+ * [locator.pressSequentially(text[, options])](https://playwright.dev/docs/api/class-locator#locator-press-sequentially).+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param text A text to type into a focused element.+ * @param options+ */+ type(selector: string, text: string, options?: {+ /**+ * Time to wait between key presses in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.uncheck([options])](https://playwright.dev/docs/api/class-locator#locator-uncheck)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method checks an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-uncheck-option-selector) by performing the following+ * steps:+ * 1. Find an element matching+ * [`selector`](https://playwright.dev/docs/api/class-frame#frame-uncheck-option-selector). If there is none,+ * wait until a matching element is attached to the DOM.+ * 1. Ensure that matched element is a checkbox or a radio input. If not, this method throws. If the element is+ * already unchecked, this method returns immediately.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-frame#frame-uncheck-option-force) option is set. If the+ * element is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element.+ * 1. Ensure that the element is now unchecked. If not, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-frame#frame-uncheck-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param selector A selector to search for an element. If there are multiple elements satisfying the selector, the first will be+ * used.+ * @param options+ */+ uncheck(selector: string, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * Returns frame's url.+ */+ url(): string;++ /**+ * Waits for the required load state to be reached.+ *+ * This returns when the frame reaches a required load state, `load` by default. The navigation must have been+ * committed when this method is called. If current document has already reached the required state, resolves+ * immediately.+ *+ * **NOTE** Most of the time, this method is not needed because Playwright+ * [auto-waits before every action](https://playwright.dev/docs/actionability).+ *+ * **Usage**+ *+ * ```js+ * await frame.click('button'); // Click triggers navigation.+ * await frame.waitForLoadState(); // Waits for 'load' state by default.+ * ```+ *+ * @param state Optional load state to wait for, defaults to `load`. If the state has been already reached while loading current+ * document, the method resolves immediately. Can be one of:+ * - `'load'` - wait for the `load` event to be fired.+ * - `'domcontentloaded'` - wait for the `DOMContentLoaded` event to be fired.+ * - `'networkidle'` - **DISCOURAGED** wait until there are no network connections for at least `500` ms. Don't use+ * this method for testing, rely on web assertions to assess readiness instead.+ * @param options+ */+ waitForLoadState(state?: "load"|"domcontentloaded"|"networkidle", options?: {+ /**+ * Maximum operation time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via+ * `navigationTimeout` option in the config, or by using the+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout),+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout),+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Waits for the frame navigation and returns the main resource response. In case of multiple redirects, the+ * navigation will resolve with the response of the last redirect. In case of navigation to a different anchor or+ * navigation due to History API usage, the navigation will resolve with `null`.+ *+ * **Usage**+ *+ * This method waits for the frame to navigate to a new URL. It is useful for when you run code which will indirectly+ * cause the frame to navigate. Consider this example:+ *+ * ```js+ * // Start waiting for navigation before clicking. Note no await.+ * const navigationPromise = page.waitForNavigation();+ * await page.getByText('Navigate after timeout').click();+ * await navigationPromise;+ * ```+ *+ * **NOTE** Usage of the [History API](https://developer.mozilla.org/en-US/docs/Web/API/History_API) to change the URL+ * is considered a navigation.+ *+ * @deprecated This method is inherently racy, please use+ * [frame.waitForURL(url[, options])](https://playwright.dev/docs/api/class-frame#frame-wait-for-url) instead.+ * @param options+ */+ waitForNavigation(options?: {+ /**+ * Maximum operation time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via+ * `navigationTimeout` option in the config, or by using the+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout),+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout),+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * A glob pattern, regex pattern or predicate receiving [URL] to match while waiting for the navigation. Note that if+ * the parameter is a string without wildcard characters, the method will wait for navigation to URL that is exactly+ * equal to the string.+ */+ url?: string|RegExp|((url: URL) => boolean);++ /**+ * When to consider operation succeeded, defaults to `load`. Events can be either:+ * - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.+ * - `'load'` - consider operation to be finished when the `load` event is fired.+ * - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for+ * at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.+ * - `'commit'` - consider operation to be finished when network response is received and the document started+ * loading.+ */+ waitUntil?: "load"|"domcontentloaded"|"networkidle"|"commit";+ }): Promise<null|Response>;++ /**+ * **NOTE** Never wait for timeout in production. Tests that wait for time are inherently flaky. Use+ * [Locator](https://playwright.dev/docs/api/class-locator) actions and web assertions that wait automatically.+ *+ * Waits for the given [`timeout`](https://playwright.dev/docs/api/class-frame#frame-wait-for-timeout-option-timeout)+ * in milliseconds.+ *+ * Note that `frame.waitForTimeout()` should only be used for debugging. Tests using the timer in production are going+ * to be flaky. Use signals such as network events, selectors becoming visible and others instead.+ * @param timeout A timeout to wait for+ */+ waitForTimeout(timeout: number): Promise<void>;++ /**+ * Waits for the frame to navigate to the given URL.+ *+ * **Usage**+ *+ * ```js+ * await frame.click('a.delayed-navigation'); // Clicking the link will indirectly cause a navigation+ * await frame.waitForURL('**\/target.html');+ * ```+ *+ * @param url A glob pattern, regex pattern or predicate receiving [URL] to match while waiting for the navigation. Note that if+ * the parameter is a string without wildcard characters, the method will wait for navigation to URL that is exactly+ * equal to the string.+ * @param options+ */+ waitForURL(url: string|RegExp|((url: URL) => boolean), options?: {+ /**+ * Maximum operation time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via+ * `navigationTimeout` option in the config, or by using the+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout),+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout),+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When to consider operation succeeded, defaults to `load`. Events can be either:+ * - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.+ * - `'load'` - consider operation to be finished when the `load` event is fired.+ * - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for+ * at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.+ * - `'commit'` - consider operation to be finished when network response is received and the document started+ * loading.+ */+ waitUntil?: "load"|"domcontentloaded"|"networkidle"|"commit";+ }): Promise<void>;+}++/**+ * BrowserContexts provide a way to operate multiple independent browser sessions.+ *+ * If a page opens another page, e.g. with a `window.open` call, the popup will belong to the parent page's browser+ * context.+ *+ * Playwright allows creating isolated non-persistent browser contexts with+ * [browser.newContext([options])](https://playwright.dev/docs/api/class-browser#browser-new-context) method.+ * Non-persistent browser contexts don't write any browsing data to disk.+ *+ * ```js+ * // Create a new incognito browser context+ * const context = await browser.newContext();+ * // Create a new page inside context.+ * const page = await context.newPage();+ * await page.goto('https://example.com');+ * // Dispose context once it's no longer needed.+ * await context.close();+ * ```+ *+ */+export interface BrowserContext {+ /**+ * The method adds a function called+ * [`name`](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-binding-option-name) on the+ * `window` object of every frame in every page in the context. When called, the function executes+ * [`callback`](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-binding-option-callback)+ * and returns a [Promise] which resolves to the return value of+ * [`callback`](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-binding-option-callback).+ * If the+ * [`callback`](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-binding-option-callback)+ * returns a [Promise], it will be awaited.+ *+ * The first argument of the+ * [`callback`](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-binding-option-callback)+ * function contains information about the caller: `{ browserContext: BrowserContext, page: Page, frame: Frame }`.+ *+ * See [page.exposeBinding(name, callback[, options])](https://playwright.dev/docs/api/class-page#page-expose-binding)+ * for page-only version.+ *+ * **Usage**+ *+ * An example of exposing page URL to all frames in all pages in the context:+ *+ * ```js+ * const { webkit } = require('playwright'); // Or 'chromium' or 'firefox'.+ *+ * (async () => {+ * const browser = await webkit.launch({ headless: false });+ * const context = await browser.newContext();+ * await context.exposeBinding('pageURL', ({ page }) => page.url());+ * const page = await context.newPage();+ * await page.setContent(`+ * <script>+ * async function onClick() {+ * document.querySelector('div').textContent = await window.pageURL();+ * }+ * </script>+ * <button onclick="onClick()">Click me</button>+ * <div></div>+ * `);+ * await page.getByRole('button').click();+ * })();+ * ```+ *+ * @param name Name of the function on the window object.+ * @param callback Callback function that will be called in the Playwright's context.+ * @param options+ */+ exposeBinding(name: string, playwrightBinding: (source: BindingSource, arg: JSHandle) => any, options: { handle: true }): Promise<void>;+ /**+ * The method adds a function called+ * [`name`](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-binding-option-name) on the+ * `window` object of every frame in every page in the context. When called, the function executes+ * [`callback`](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-binding-option-callback)+ * and returns a [Promise] which resolves to the return value of+ * [`callback`](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-binding-option-callback).+ * If the+ * [`callback`](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-binding-option-callback)+ * returns a [Promise], it will be awaited.+ *+ * The first argument of the+ * [`callback`](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-binding-option-callback)+ * function contains information about the caller: `{ browserContext: BrowserContext, page: Page, frame: Frame }`.+ *+ * See [page.exposeBinding(name, callback[, options])](https://playwright.dev/docs/api/class-page#page-expose-binding)+ * for page-only version.+ *+ * **Usage**+ *+ * An example of exposing page URL to all frames in all pages in the context:+ *+ * ```js+ * const { webkit } = require('playwright'); // Or 'chromium' or 'firefox'.+ *+ * (async () => {+ * const browser = await webkit.launch({ headless: false });+ * const context = await browser.newContext();+ * await context.exposeBinding('pageURL', ({ page }) => page.url());+ * const page = await context.newPage();+ * await page.setContent(`+ * <script>+ * async function onClick() {+ * document.querySelector('div').textContent = await window.pageURL();+ * }+ * </script>+ * <button onclick="onClick()">Click me</button>+ * <div></div>+ * `);+ * await page.getByRole('button').click();+ * })();+ * ```+ *+ * @param name Name of the function on the window object.+ * @param callback Callback function that will be called in the Playwright's context.+ * @param options+ */+ exposeBinding(name: string, playwrightBinding: (source: BindingSource, ...args: any[]) => any, options?: { handle?: boolean }): Promise<void>;++ /**+ * Adds a script which would be evaluated in one of the following scenarios:+ * - Whenever a page is created in the browser context or is navigated.+ * - Whenever a child frame is attached or navigated in any page in the browser context. In this case, the script is+ * evaluated in the context of the newly attached frame.+ *+ * The script is evaluated after the document was created but before any of its scripts were run. This is useful to+ * amend the JavaScript environment, e.g. to seed `Math.random`.+ *+ * **Usage**+ *+ * An example of overriding `Math.random` before the page loads:+ *+ * ```js+ * // preload.js+ * Math.random = () => 42;+ * ```+ *+ * ```js+ * // In your playwright script, assuming the preload.js file is in same directory.+ * await browserContext.addInitScript({+ * path: 'preload.js'+ * });+ * ```+ *+ * **NOTE** The order of evaluation of multiple scripts installed via+ * [browserContext.addInitScript(script[, arg])](https://playwright.dev/docs/api/class-browsercontext#browser-context-add-init-script)+ * and [page.addInitScript(script[, arg])](https://playwright.dev/docs/api/class-page#page-add-init-script) is not+ * defined.+ *+ * @param script Script to be evaluated in all pages in the browser context.+ * @param arg Optional argument to pass to+ * [`script`](https://playwright.dev/docs/api/class-browsercontext#browser-context-add-init-script-option-script)+ * (only supported when passing a function).+ */+ addInitScript<Arg>(script: PageFunction<Arg, any> | { path?: string, content?: string }, arg?: Arg): Promise<void>;++ /**+ * Removes all the listeners of the given type (or all registered listeners if no type given). Allows to wait for+ * async listeners to complete or to ignore subsequent errors from these listeners.+ * @param type+ * @param options+ */+ removeAllListeners(type?: string): this;+ /**+ * Removes all the listeners of the given type (or all registered listeners if no type given). Allows to wait for+ * async listeners to complete or to ignore subsequent errors from these listeners.+ * @param type+ * @param options+ */+ removeAllListeners(type: string | undefined, options: {+ /**+ * Specifies whether to wait for already running listeners and what to do if they throw errors:+ * - `'default'` - do not wait for current listener calls (if any) to finish, if the listener throws, it may result in unhandled error+ * - `'wait'` - wait for current listener calls (if any) to finish+ * - `'ignoreErrors'` - do not wait for current listener calls (if any) to finish, all errors thrown by the listeners after removal are silently caught+ */+ behavior?: 'wait'|'ignoreErrors'|'default'+ }): Promise<void>;+ /**+ * **NOTE** Only works with Chromium browser's persistent context.+ *+ * Emitted when new background page is created in the context.+ *+ * ```js+ * const backgroundPage = await context.waitForEvent('backgroundpage');+ * ```+ *+ */+ on(event: 'backgroundpage', listener: (page: Page) => any): this;++ /**+ * Emitted when Browser context gets closed. This might happen because of one of the following:+ * - Browser context is closed.+ * - Browser application is closed or crashed.+ * - The [browser.close([options])](https://playwright.dev/docs/api/class-browser#browser-close) method was called.+ */+ on(event: 'close', listener: (browserContext: BrowserContext) => any): this;++ /**+ * Emitted when JavaScript within the page calls one of console API methods, e.g. `console.log` or `console.dir`.+ *+ * The arguments passed into `console.log` and the page are available on the+ * [ConsoleMessage](https://playwright.dev/docs/api/class-consolemessage) event handler argument.+ *+ * **Usage**+ *+ * ```js+ * context.on('console', async msg => {+ * const values = [];+ * for (const arg of msg.args())+ * values.push(await arg.jsonValue());+ * console.log(...values);+ * });+ * await page.evaluate(() => console.log('hello', 5, { foo: 'bar' }));+ * ```+ *+ */+ on(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**+ * either [dialog.accept([promptText])](https://playwright.dev/docs/api/class-dialog#dialog-accept) or+ * [dialog.dismiss()](https://playwright.dev/docs/api/class-dialog#dialog-dismiss) the dialog - otherwise the page+ * will [freeze](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#never_blocking) waiting for the+ * dialog, and actions like click will never finish.+ *+ * **Usage**+ *+ * ```js+ * context.on('dialog', dialog => {+ * dialog.accept();+ * });+ * ```+ *+ * **NOTE** When no [page.on('dialog')](https://playwright.dev/docs/api/class-page#page-event-dialog) or+ * [browserContext.on('dialog')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-dialog)+ * listeners are present, all dialogs are automatically dismissed.+ *+ */+ on(event: 'dialog', listener: (dialog: Dialog) => any): this;++ /**+ * The event is emitted when a new Page is created in the BrowserContext. The page may still be loading. The event+ * will also fire for popup pages. See also+ * [page.on('popup')](https://playwright.dev/docs/api/class-page#page-event-popup) to receive events about popups+ * relevant to a specific page.+ *+ * The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a+ * popup with `window.open('http://example.com')`, this event will fire when the network request to+ * "http://example.com" is done and its response has started loading in the popup. If you would like to route/listen+ * to this network request, use+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * and+ * [browserContext.on('request')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request)+ * respectively instead of similar methods on the [Page](https://playwright.dev/docs/api/class-page).+ *+ * ```js+ * const newPagePromise = context.waitForEvent('page');+ * await page.getByText('open new page').click();+ * const newPage = await newPagePromise;+ * console.log(await newPage.evaluate('location.href'));+ * ```+ *+ * **NOTE** Use+ * [page.waitForLoadState([state, options])](https://playwright.dev/docs/api/class-page#page-wait-for-load-state) to+ * wait until the page gets to a particular state (you should not need it in most cases).+ *+ */+ on(event: 'page', listener: (page: Page) => any): this;++ /**+ * Emitted when a request is issued from any pages created through this context. The [request] object is read-only. To+ * only listen for requests from a particular page, use+ * [page.on('request')](https://playwright.dev/docs/api/class-page#page-event-request).+ *+ * In order to intercept and mutate requests, see+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * or [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route).+ */+ on(event: 'request', listener: (request: Request) => any): this;++ /**+ * Emitted when a request fails, for example by timing out. To only listen for failed requests from a particular page,+ * use [page.on('requestfailed')](https://playwright.dev/docs/api/class-page#page-event-request-failed).+ *+ * **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request+ * will complete with+ * [browserContext.on('requestfinished')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request-finished)+ * event and not with+ * [browserContext.on('requestfailed')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request-failed).+ *+ */+ on(event: 'requestfailed', listener: (request: Request) => any): this;++ /**+ * Emitted when a request finishes successfully after downloading the response body. For a successful response, the+ * sequence of events is `request`, `response` and `requestfinished`. To listen for successful requests from a+ * particular page, use+ * [page.on('requestfinished')](https://playwright.dev/docs/api/class-page#page-event-request-finished).+ */+ on(event: 'requestfinished', listener: (request: Request) => any): this;++ /**+ * Emitted when [response] status and headers are received for a request. For a successful response, the sequence of+ * events is `request`, `response` and `requestfinished`. To listen for response events from a particular page, use+ * [page.on('response')](https://playwright.dev/docs/api/class-page#page-event-response).+ */+ on(event: 'response', listener: (response: Response) => any): this;++ /**+ * **NOTE** Service workers are only supported on Chromium-based browsers.+ *+ * Emitted when new service worker is created in the context.+ */+ on(event: 'serviceworker', listener: (worker: Worker) => any): this;++ /**+ * Emitted when exception is unhandled in any of the pages in this context. To listen for errors from a particular+ * page, use [page.on('pageerror')](https://playwright.dev/docs/api/class-page#page-event-page-error) instead.+ */+ on(event: 'weberror', listener: (webError: WebError) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'backgroundpage', listener: (page: Page) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'close', listener: (browserContext: BrowserContext) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'dialog', listener: (dialog: Dialog) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'page', listener: (page: Page) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'request', listener: (request: Request) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'requestfailed', listener: (request: Request) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'requestfinished', listener: (request: Request) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'response', listener: (response: Response) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'serviceworker', listener: (worker: Worker) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'weberror', listener: (webError: WebError) => any): this;++ /**+ * **NOTE** Only works with Chromium browser's persistent context.+ *+ * Emitted when new background page is created in the context.+ *+ * ```js+ * const backgroundPage = await context.waitForEvent('backgroundpage');+ * ```+ *+ */+ addListener(event: 'backgroundpage', listener: (page: Page) => any): this;++ /**+ * Emitted when Browser context gets closed. This might happen because of one of the following:+ * - Browser context is closed.+ * - Browser application is closed or crashed.+ * - The [browser.close([options])](https://playwright.dev/docs/api/class-browser#browser-close) method was called.+ */+ addListener(event: 'close', listener: (browserContext: BrowserContext) => any): this;++ /**+ * Emitted when JavaScript within the page calls one of console API methods, e.g. `console.log` or `console.dir`.+ *+ * The arguments passed into `console.log` and the page are available on the+ * [ConsoleMessage](https://playwright.dev/docs/api/class-consolemessage) event handler argument.+ *+ * **Usage**+ *+ * ```js+ * context.on('console', async msg => {+ * const values = [];+ * for (const arg of msg.args())+ * values.push(await arg.jsonValue());+ * console.log(...values);+ * });+ * await page.evaluate(() => console.log('hello', 5, { foo: 'bar' }));+ * ```+ *+ */+ addListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**+ * either [dialog.accept([promptText])](https://playwright.dev/docs/api/class-dialog#dialog-accept) or+ * [dialog.dismiss()](https://playwright.dev/docs/api/class-dialog#dialog-dismiss) the dialog - otherwise the page+ * will [freeze](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#never_blocking) waiting for the+ * dialog, and actions like click will never finish.+ *+ * **Usage**+ *+ * ```js+ * context.on('dialog', dialog => {+ * dialog.accept();+ * });+ * ```+ *+ * **NOTE** When no [page.on('dialog')](https://playwright.dev/docs/api/class-page#page-event-dialog) or+ * [browserContext.on('dialog')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-dialog)+ * listeners are present, all dialogs are automatically dismissed.+ *+ */+ addListener(event: 'dialog', listener: (dialog: Dialog) => any): this;++ /**+ * The event is emitted when a new Page is created in the BrowserContext. The page may still be loading. The event+ * will also fire for popup pages. See also+ * [page.on('popup')](https://playwright.dev/docs/api/class-page#page-event-popup) to receive events about popups+ * relevant to a specific page.+ *+ * The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a+ * popup with `window.open('http://example.com')`, this event will fire when the network request to+ * "http://example.com" is done and its response has started loading in the popup. If you would like to route/listen+ * to this network request, use+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * and+ * [browserContext.on('request')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request)+ * respectively instead of similar methods on the [Page](https://playwright.dev/docs/api/class-page).+ *+ * ```js+ * const newPagePromise = context.waitForEvent('page');+ * await page.getByText('open new page').click();+ * const newPage = await newPagePromise;+ * console.log(await newPage.evaluate('location.href'));+ * ```+ *+ * **NOTE** Use+ * [page.waitForLoadState([state, options])](https://playwright.dev/docs/api/class-page#page-wait-for-load-state) to+ * wait until the page gets to a particular state (you should not need it in most cases).+ *+ */+ addListener(event: 'page', listener: (page: Page) => any): this;++ /**+ * Emitted when a request is issued from any pages created through this context. The [request] object is read-only. To+ * only listen for requests from a particular page, use+ * [page.on('request')](https://playwright.dev/docs/api/class-page#page-event-request).+ *+ * In order to intercept and mutate requests, see+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * or [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route).+ */+ addListener(event: 'request', listener: (request: Request) => any): this;++ /**+ * Emitted when a request fails, for example by timing out. To only listen for failed requests from a particular page,+ * use [page.on('requestfailed')](https://playwright.dev/docs/api/class-page#page-event-request-failed).+ *+ * **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request+ * will complete with+ * [browserContext.on('requestfinished')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request-finished)+ * event and not with+ * [browserContext.on('requestfailed')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request-failed).+ *+ */+ addListener(event: 'requestfailed', listener: (request: Request) => any): this;++ /**+ * Emitted when a request finishes successfully after downloading the response body. For a successful response, the+ * sequence of events is `request`, `response` and `requestfinished`. To listen for successful requests from a+ * particular page, use+ * [page.on('requestfinished')](https://playwright.dev/docs/api/class-page#page-event-request-finished).+ */+ addListener(event: 'requestfinished', listener: (request: Request) => any): this;++ /**+ * Emitted when [response] status and headers are received for a request. For a successful response, the sequence of+ * events is `request`, `response` and `requestfinished`. To listen for response events from a particular page, use+ * [page.on('response')](https://playwright.dev/docs/api/class-page#page-event-response).+ */+ addListener(event: 'response', listener: (response: Response) => any): this;++ /**+ * **NOTE** Service workers are only supported on Chromium-based browsers.+ *+ * Emitted when new service worker is created in the context.+ */+ addListener(event: 'serviceworker', listener: (worker: Worker) => any): this;++ /**+ * Emitted when exception is unhandled in any of the pages in this context. To listen for errors from a particular+ * page, use [page.on('pageerror')](https://playwright.dev/docs/api/class-page#page-event-page-error) instead.+ */+ addListener(event: 'weberror', listener: (webError: WebError) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'backgroundpage', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'close', listener: (browserContext: BrowserContext) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'dialog', listener: (dialog: Dialog) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'page', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'request', listener: (request: Request) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'requestfailed', listener: (request: Request) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'requestfinished', listener: (request: Request) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'response', listener: (response: Response) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'serviceworker', listener: (worker: Worker) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'weberror', listener: (webError: WebError) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'backgroundpage', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'close', listener: (browserContext: BrowserContext) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'dialog', listener: (dialog: Dialog) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'page', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'request', listener: (request: Request) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'requestfailed', listener: (request: Request) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'requestfinished', listener: (request: Request) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'response', listener: (response: Response) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'serviceworker', listener: (worker: Worker) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'weberror', listener: (webError: WebError) => any): this;++ /**+ * **NOTE** Only works with Chromium browser's persistent context.+ *+ * Emitted when new background page is created in the context.+ *+ * ```js+ * const backgroundPage = await context.waitForEvent('backgroundpage');+ * ```+ *+ */+ prependListener(event: 'backgroundpage', listener: (page: Page) => any): this;++ /**+ * Emitted when Browser context gets closed. This might happen because of one of the following:+ * - Browser context is closed.+ * - Browser application is closed or crashed.+ * - The [browser.close([options])](https://playwright.dev/docs/api/class-browser#browser-close) method was called.+ */+ prependListener(event: 'close', listener: (browserContext: BrowserContext) => any): this;++ /**+ * Emitted when JavaScript within the page calls one of console API methods, e.g. `console.log` or `console.dir`.+ *+ * The arguments passed into `console.log` and the page are available on the+ * [ConsoleMessage](https://playwright.dev/docs/api/class-consolemessage) event handler argument.+ *+ * **Usage**+ *+ * ```js+ * context.on('console', async msg => {+ * const values = [];+ * for (const arg of msg.args())+ * values.push(await arg.jsonValue());+ * console.log(...values);+ * });+ * await page.evaluate(() => console.log('hello', 5, { foo: 'bar' }));+ * ```+ *+ */+ prependListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**+ * either [dialog.accept([promptText])](https://playwright.dev/docs/api/class-dialog#dialog-accept) or+ * [dialog.dismiss()](https://playwright.dev/docs/api/class-dialog#dialog-dismiss) the dialog - otherwise the page+ * will [freeze](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#never_blocking) waiting for the+ * dialog, and actions like click will never finish.+ *+ * **Usage**+ *+ * ```js+ * context.on('dialog', dialog => {+ * dialog.accept();+ * });+ * ```+ *+ * **NOTE** When no [page.on('dialog')](https://playwright.dev/docs/api/class-page#page-event-dialog) or+ * [browserContext.on('dialog')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-dialog)+ * listeners are present, all dialogs are automatically dismissed.+ *+ */+ prependListener(event: 'dialog', listener: (dialog: Dialog) => any): this;++ /**+ * The event is emitted when a new Page is created in the BrowserContext. The page may still be loading. The event+ * will also fire for popup pages. See also+ * [page.on('popup')](https://playwright.dev/docs/api/class-page#page-event-popup) to receive events about popups+ * relevant to a specific page.+ *+ * The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a+ * popup with `window.open('http://example.com')`, this event will fire when the network request to+ * "http://example.com" is done and its response has started loading in the popup. If you would like to route/listen+ * to this network request, use+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * and+ * [browserContext.on('request')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request)+ * respectively instead of similar methods on the [Page](https://playwright.dev/docs/api/class-page).+ *+ * ```js+ * const newPagePromise = context.waitForEvent('page');+ * await page.getByText('open new page').click();+ * const newPage = await newPagePromise;+ * console.log(await newPage.evaluate('location.href'));+ * ```+ *+ * **NOTE** Use+ * [page.waitForLoadState([state, options])](https://playwright.dev/docs/api/class-page#page-wait-for-load-state) to+ * wait until the page gets to a particular state (you should not need it in most cases).+ *+ */+ prependListener(event: 'page', listener: (page: Page) => any): this;++ /**+ * Emitted when a request is issued from any pages created through this context. The [request] object is read-only. To+ * only listen for requests from a particular page, use+ * [page.on('request')](https://playwright.dev/docs/api/class-page#page-event-request).+ *+ * In order to intercept and mutate requests, see+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * or [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route).+ */+ prependListener(event: 'request', listener: (request: Request) => any): this;++ /**+ * Emitted when a request fails, for example by timing out. To only listen for failed requests from a particular page,+ * use [page.on('requestfailed')](https://playwright.dev/docs/api/class-page#page-event-request-failed).+ *+ * **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request+ * will complete with+ * [browserContext.on('requestfinished')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request-finished)+ * event and not with+ * [browserContext.on('requestfailed')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request-failed).+ *+ */+ prependListener(event: 'requestfailed', listener: (request: Request) => any): this;++ /**+ * Emitted when a request finishes successfully after downloading the response body. For a successful response, the+ * sequence of events is `request`, `response` and `requestfinished`. To listen for successful requests from a+ * particular page, use+ * [page.on('requestfinished')](https://playwright.dev/docs/api/class-page#page-event-request-finished).+ */+ prependListener(event: 'requestfinished', listener: (request: Request) => any): this;++ /**+ * Emitted when [response] status and headers are received for a request. For a successful response, the sequence of+ * events is `request`, `response` and `requestfinished`. To listen for response events from a particular page, use+ * [page.on('response')](https://playwright.dev/docs/api/class-page#page-event-response).+ */+ prependListener(event: 'response', listener: (response: Response) => any): this;++ /**+ * **NOTE** Service workers are only supported on Chromium-based browsers.+ *+ * Emitted when new service worker is created in the context.+ */+ prependListener(event: 'serviceworker', listener: (worker: Worker) => any): this;++ /**+ * Emitted when exception is unhandled in any of the pages in this context. To listen for errors from a particular+ * page, use [page.on('pageerror')](https://playwright.dev/docs/api/class-page#page-event-page-error) instead.+ */+ prependListener(event: 'weberror', listener: (webError: WebError) => any): this;++ /**+ * Adds cookies into this browser context. All pages within this context will have these cookies installed. Cookies+ * can be obtained via+ * [browserContext.cookies([urls])](https://playwright.dev/docs/api/class-browsercontext#browser-context-cookies).+ *+ * **Usage**+ *+ * ```js+ * await browserContext.addCookies([cookieObject1, cookieObject2]);+ * ```+ *+ * @param cookies+ */+ addCookies(cookies: ReadonlyArray<{+ name: string;++ value: string;++ /**+ * Either url or domain / path are required. Optional.+ */+ url?: string;++ /**+ * For the cookie to apply to all subdomains as well, prefix domain with a dot, like this: ".example.com". Either url+ * or domain / path are required. Optional.+ */+ domain?: string;++ /**+ * Either url or domain / path are required Optional.+ */+ path?: string;++ /**+ * Unix time in seconds. Optional.+ */+ expires?: number;++ /**+ * Optional.+ */+ httpOnly?: boolean;++ /**+ * Optional.+ */+ secure?: boolean;++ /**+ * Optional.+ */+ sameSite?: "Strict"|"Lax"|"None";+ }>): Promise<void>;++ /**+ * **NOTE** Background pages are only supported on Chromium-based browsers.+ *+ * All existing background pages in the context.+ */+ backgroundPages(): Array<Page>;++ /**+ * Returns the browser instance of the context. If it was launched as a persistent context null gets returned.+ */+ browser(): null|Browser;++ /**+ * Removes cookies from context. Accepts optional filter.+ *+ * **Usage**+ *+ * ```js+ * await context.clearCookies();+ * await context.clearCookies({ name: 'session-id' });+ * await context.clearCookies({ domain: 'my-origin.com' });+ * await context.clearCookies({ domain: /.*my-origin\.com/ });+ * await context.clearCookies({ path: '/api/v1' });+ * await context.clearCookies({ name: 'session-id', domain: 'my-origin.com' });+ * ```+ *+ * @param options+ */+ clearCookies(options?: {+ /**+ * Only removes cookies with the given domain.+ */+ domain?: string|RegExp;++ /**+ * Only removes cookies with the given name.+ */+ name?: string|RegExp;++ /**+ * Only removes cookies with the given path.+ */+ path?: string|RegExp;+ }): Promise<void>;++ /**+ * Clears all permission overrides for the browser context.+ *+ * **Usage**+ *+ * ```js+ * const context = await browser.newContext();+ * await context.grantPermissions(['clipboard-read']);+ * // do stuff ..+ * context.clearPermissions();+ * ```+ *+ */+ clearPermissions(): Promise<void>;++ /**+ * Closes the browser context. All the pages that belong to the browser context will be closed.+ *+ * **NOTE** The default browser context cannot be closed.+ *+ * @param options+ */+ close(options?: {+ /**+ * The reason to be reported to the operations interrupted by the context closure.+ */+ reason?: string;+ }): Promise<void>;++ /**+ * If no URLs are specified, this method returns all cookies. If URLs are specified, only cookies that affect those+ * URLs are returned.+ * @param urls Optional list of URLs.+ */+ cookies(urls?: string|ReadonlyArray<string>): Promise<Array<Cookie>>;++ /**+ * The method adds a function called+ * [`name`](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-function-option-name) on the+ * `window` object of every frame in every page in the context. When called, the function executes+ * [`callback`](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-function-option-callback)+ * and returns a [Promise] which resolves to the return value of+ * [`callback`](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-function-option-callback).+ *+ * If the+ * [`callback`](https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-function-option-callback)+ * returns a [Promise], it will be awaited.+ *+ * See [page.exposeFunction(name, callback)](https://playwright.dev/docs/api/class-page#page-expose-function) for+ * page-only version.+ *+ * **Usage**+ *+ * An example of adding a `sha256` function to all pages in the context:+ *+ * ```js+ * const { webkit } = require('playwright'); // Or 'chromium' or 'firefox'.+ * const crypto = require('crypto');+ *+ * (async () => {+ * const browser = await webkit.launch({ headless: false });+ * const context = await browser.newContext();+ * await context.exposeFunction('sha256', text =>+ * crypto.createHash('sha256').update(text).digest('hex'),+ * );+ * const page = await context.newPage();+ * await page.setContent(`+ * <script>+ * async function onClick() {+ * document.querySelector('div').textContent = await window.sha256('PLAYWRIGHT');+ * }+ * </script>+ * <button onclick="onClick()">Click me</button>+ * <div></div>+ * `);+ * await page.getByRole('button').click();+ * })();+ * ```+ *+ * @param name Name of the function on the window object.+ * @param callback Callback function that will be called in the Playwright's context.+ */+ exposeFunction(name: string, callback: Function): Promise<void>;++ /**+ * Grants specified permissions to the browser context. Only grants corresponding permissions to the given origin if+ * specified.+ * @param permissions A list of permissions to grant.+ *+ * **NOTE** Supported permissions differ between browsers, and even between different versions of the same browser.+ * Any permission may stop working after an update.+ *+ * Here are some permissions that may be supported by some browsers:+ * - `'accelerometer'`+ * - `'ambient-light-sensor'`+ * - `'background-sync'`+ * - `'camera'`+ * - `'clipboard-read'`+ * - `'clipboard-write'`+ * - `'geolocation'`+ * - `'gyroscope'`+ * - `'magnetometer'`+ * - `'microphone'`+ * - `'midi-sysex'` (system-exclusive midi)+ * - `'midi'`+ * - `'notifications'`+ * - `'payment-handler'`+ * - `'storage-access'`+ * @param options+ */+ grantPermissions(permissions: ReadonlyArray<string>, options?: {+ /**+ * The [origin] to grant permissions to, e.g. "https://example.com".+ */+ origin?: string;+ }): Promise<void>;++ /**+ * **NOTE** CDP sessions are only supported on Chromium-based browsers.+ *+ * Returns the newly created session.+ * @param page Target to create new session for. For backwards-compatibility, this parameter is named `page`, but it can be a+ * `Page` or `Frame` type.+ */+ newCDPSession(page: Page|Frame): Promise<CDPSession>;++ /**+ * Creates a new page in the browser context.+ */+ newPage(): Promise<Page>;++ /**+ * Returns all open pages in the context.+ */+ pages(): Array<Page>;++ /**+ * Routing provides the capability to modify network requests that are made by any page in the browser context. Once+ * route is enabled, every request matching the url pattern will stall unless it's continued, fulfilled or aborted.+ *+ * **NOTE**+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * will not intercept requests intercepted by Service Worker. See+ * [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when+ * using request interception by setting+ * [`serviceWorkers`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-service-workers) to+ * `'block'`.+ *+ * **Usage**+ *+ * An example of a naive handler that aborts all image requests:+ *+ * ```js+ * const context = await browser.newContext();+ * await context.route('**\/*.{png,jpg,jpeg}', route => route.abort());+ * const page = await context.newPage();+ * await page.goto('https://example.com');+ * await browser.close();+ * ```+ *+ * or the same snippet using a regex pattern instead:+ *+ * ```js+ * const context = await browser.newContext();+ * await context.route(/(\.png$)|(\.jpg$)/, route => route.abort());+ * const page = await context.newPage();+ * await page.goto('https://example.com');+ * await browser.close();+ * ```+ *+ * It is possible to examine the request to decide the route action. For example, mocking all requests that contain+ * some post data, and leaving all other requests as is:+ *+ * ```js+ * await context.route('/api/**', async route => {+ * if (route.request().postData().includes('my-string'))+ * await route.fulfill({ body: 'mocked-data' });+ * else+ * await route.continue();+ * });+ * ```+ *+ * Page routes (set up with+ * [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route)) take precedence over+ * browser context routes when request matches both handlers.+ *+ * To remove a route with its handler you can use+ * [browserContext.unroute(url[, handler])](https://playwright.dev/docs/api/class-browsercontext#browser-context-unroute).+ *+ * **NOTE** Enabling routing disables http cache.+ *+ * @param url A glob pattern, regex pattern or predicate receiving [URL] to match while routing. When a+ * [`baseURL`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-base-url) via the context+ * options was provided and the passed URL is a path, it gets merged via the+ * [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.+ * @param handler handler function to route the request.+ * @param options+ */+ route(url: string|RegExp|((url: URL) => boolean), handler: ((route: Route, request: Request) => Promise<any>|any), options?: {+ /**+ * How often a route should be used. By default it will be used every time.+ */+ times?: number;+ }): Promise<void>;++ /**+ * If specified the network requests that are made in the context will be served from the HAR file. Read more about+ * [Replaying from HAR](https://playwright.dev/docs/mock#replaying-from-har).+ *+ * Playwright will not serve requests intercepted by Service Worker from the HAR file. See+ * [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when+ * using request interception by setting+ * [`serviceWorkers`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-service-workers) to+ * `'block'`.+ * @param har Path to a [HAR](http://www.softwareishard.com/blog/har-12-spec) file with prerecorded network data. If `path` is a+ * relative path, then it is resolved relative to the current working directory.+ * @param options+ */+ routeFromHAR(har: string, options?: {+ /**+ * - If set to 'abort' any request not found in the HAR file will be aborted.+ * - If set to 'fallback' falls through to the next route handler in the handler chain.+ *+ * Defaults to abort.+ */+ notFound?: "abort"|"fallback";++ /**+ * If specified, updates the given HAR with the actual network information instead of serving from file. The file is+ * written to disk when+ * [browserContext.close([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-close) is+ * called.+ */+ update?: boolean;++ /**+ * Optional setting to control resource content management. If `attach` is specified, resources are persisted as+ * separate files or entries in the ZIP archive. If `embed` is specified, content is stored inline the HAR file.+ */+ updateContent?: "embed"|"attach";++ /**+ * When set to `minimal`, only record information necessary for routing from HAR. This omits sizes, timing, page,+ * cookies, security and other types of HAR information that are not used when replaying from HAR. Defaults to+ * `minimal`.+ */+ updateMode?: "full"|"minimal";++ /**+ * A glob pattern, regular expression or predicate to match the request URL. Only requests with URL matching the+ * pattern will be served from the HAR file. If not specified, all requests are served from the HAR file.+ */+ url?: string|RegExp;+ }): Promise<void>;++ /**+ * This method allows to modify websocket connections that are made by any page in the browser context.+ *+ * Note that only `WebSocket`s created after this method was called will be routed. It is recommended to call this+ * method before creating any pages.+ *+ * **Usage**+ *+ * Below is an example of a simple handler that blocks some websocket messages. See+ * [WebSocketRoute](https://playwright.dev/docs/api/class-websocketroute) for more details and examples.+ *+ * ```js+ * await context.routeWebSocket('/ws', async ws => {+ * ws.routeSend(message => {+ * if (message === 'to-be-blocked')+ * return;+ * ws.send(message);+ * });+ * await ws.connect();+ * });+ * ```+ *+ * @param url Only WebSockets with the url matching this pattern will be routed. A string pattern can be relative to the+ * [`baseURL`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-base-url) context option.+ * @param handler Handler function to route the WebSocket.+ */+ routeWebSocket(url: string|RegExp|((url: URL) => boolean), handler: ((websocketroute: WebSocketRoute) => Promise<any>|any)): Promise<void>;++ /**+ * **NOTE** Service workers are only supported on Chromium-based browsers.+ *+ * All existing service workers in the context.+ */+ serviceWorkers(): Array<Worker>;++ /**+ * This setting will change the default maximum navigation time for the following methods and related shortcuts:+ * - [page.goBack([options])](https://playwright.dev/docs/api/class-page#page-go-back)+ * - [page.goForward([options])](https://playwright.dev/docs/api/class-page#page-go-forward)+ * - [page.goto(url[, options])](https://playwright.dev/docs/api/class-page#page-goto)+ * - [page.reload([options])](https://playwright.dev/docs/api/class-page#page-reload)+ * - [page.setContent(html[, options])](https://playwright.dev/docs/api/class-page#page-set-content)+ * - [page.waitForNavigation([options])](https://playwright.dev/docs/api/class-page#page-wait-for-navigation)+ *+ * **NOTE**+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)+ * and [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) take+ * priority over+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout).+ *+ * @param timeout Maximum navigation time in milliseconds+ */+ setDefaultNavigationTimeout(timeout: number): void;++ /**+ * This setting will change the default maximum time for all the methods accepting+ * [`timeout`](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout-option-timeout)+ * option.+ *+ * **NOTE**+ * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout),+ * [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) and+ * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout)+ * take priority over+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout).+ *+ * @param timeout Maximum time in milliseconds. Pass `0` to disable timeout.+ */+ setDefaultTimeout(timeout: number): void;++ /**+ * The extra HTTP headers will be sent with every request initiated by any page in the context. These headers are+ * merged with page-specific extra HTTP headers set with+ * [page.setExtraHTTPHeaders(headers)](https://playwright.dev/docs/api/class-page#page-set-extra-http-headers). If+ * page overrides a particular header, page-specific header value will be used instead of the browser context header+ * value.+ *+ * **NOTE**+ * [browserContext.setExtraHTTPHeaders(headers)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-extra-http-headers)+ * does not guarantee the order of headers in the outgoing requests.+ *+ * @param headers An object containing additional HTTP headers to be sent with every request. All header values must be strings.+ */+ setExtraHTTPHeaders(headers: { [key: string]: string; }): Promise<void>;++ /**+ * Sets the context's geolocation. Passing `null` or `undefined` emulates position unavailable.+ *+ * **Usage**+ *+ * ```js+ * await browserContext.setGeolocation({ latitude: 59.95, longitude: 30.31667 });+ * ```+ *+ * **NOTE** Consider using+ * [browserContext.grantPermissions(permissions[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-grant-permissions)+ * to grant permissions for the browser context pages to read its geolocation.+ *+ * @param geolocation+ */+ setGeolocation(geolocation: null|{+ /**+ * Latitude between -90 and 90.+ */+ latitude: number;++ /**+ * Longitude between -180 and 180.+ */+ longitude: number;++ /**+ * Non-negative accuracy value. Defaults to `0`.+ */+ accuracy?: number;+ }): Promise<void>;++ /**+ * @deprecated Browsers may cache credentials after successful authentication. Create a new browser context instead.+ * @param httpCredentials+ */+ setHTTPCredentials(httpCredentials: null|{+ username: string;++ password: string;+ }): Promise<void>;++ /**+ * @param offline Whether to emulate network being offline for the browser context.+ */+ setOffline(offline: boolean): Promise<void>;++ /**+ * Returns storage state for this browser context, contains current cookies, local storage snapshot and IndexedDB+ * snapshot.+ *+ * **NOTE** IndexedDBs with typed arrays are currently not supported.+ *+ * @param options+ */+ storageState(options?: {+ /**+ * Defaults to `true`. Set to `false` to omit IndexedDB from snapshot.+ */+ indexedDB?: boolean;++ /**+ * The file path to save the storage state to. If+ * [`path`](https://playwright.dev/docs/api/class-browsercontext#browser-context-storage-state-option-path) is a+ * relative path, then it is resolved relative to current working directory. If no path is provided, storage state is+ * still returned, but won't be saved to the disk.+ */+ path?: string;+ }): Promise<{+ cookies: Array<{+ name: string;++ value: string;++ domain: string;++ path: string;++ /**+ * Unix time in seconds.+ */+ expires: number;++ httpOnly: boolean;++ secure: boolean;++ sameSite: "Strict"|"Lax"|"None";+ }>;++ origins: Array<{+ origin: string;++ localStorage: Array<{+ name: string;++ value: string;+ }>;++ indexedDB: Array<{+ name: string;++ version: number;++ stores: Array<{+ name: string;++ keyPath?: string;++ keyPathArray?: Array<string>;++ autoIncrement: boolean;++ indexes: Array<{+ name: string;++ keyPath?: string;++ keyPathArray?: Array<string>;++ unique: boolean;++ multiEntry: boolean;+ }>;++ records: Array<{+ key?: Object;++ /**+ * if `key` is not JSON-serializable, this contains an encoded version that preserves types.+ */+ keyEncoded?: Object;++ value?: Object;++ /**+ * if `value` is not JSON-serializable, this contains an encoded version that preserves types.+ */+ valueEncoded?: Object;+ }>;+ }>;+ }>;+ }>;+ }>;++ /**+ * Removes a route created with+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route).+ * When [`handler`](https://playwright.dev/docs/api/class-browsercontext#browser-context-unroute-option-handler) is+ * not specified, removes all routes for the+ * [`url`](https://playwright.dev/docs/api/class-browsercontext#browser-context-unroute-option-url).+ * @param url A glob pattern, regex pattern or predicate receiving [URL] used to register a routing with+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route).+ * @param handler Optional handler function used to register a routing with+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route).+ */+ unroute(url: string|RegExp|((url: URL) => boolean), handler?: ((route: Route, request: Request) => Promise<any>|any)): Promise<void>;++ /**+ * Removes all routes created with+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * and+ * [browserContext.routeFromHAR(har[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route-from-har).+ * @param options+ */+ unrouteAll(options?: {+ /**+ * Specifies whether to wait for already running handlers and what to do if they throw errors:+ * - `'default'` - do not wait for current handler calls (if any) to finish, if unrouted handler throws, it may+ * result in unhandled error+ * - `'wait'` - wait for current handler calls (if any) to finish+ * - `'ignoreErrors'` - do not wait for current handler calls (if any) to finish, all errors thrown by the handlers+ * after unrouting are silently caught+ */+ behavior?: "wait"|"ignoreErrors"|"default";+ }): Promise<void>;++ /**+ * **NOTE** Only works with Chromium browser's persistent context.+ *+ * Emitted when new background page is created in the context.+ *+ * ```js+ * const backgroundPage = await context.waitForEvent('backgroundpage');+ * ```+ *+ */+ waitForEvent(event: 'backgroundpage', optionsOrPredicate?: { predicate?: (page: Page) => boolean | Promise<boolean>, timeout?: number } | ((page: Page) => boolean | Promise<boolean>)): Promise<Page>;++ /**+ * Emitted when Browser context gets closed. This might happen because of one of the following:+ * - Browser context is closed.+ * - Browser application is closed or crashed.+ * - The [browser.close([options])](https://playwright.dev/docs/api/class-browser#browser-close) method was called.+ */+ waitForEvent(event: 'close', optionsOrPredicate?: { predicate?: (browserContext: BrowserContext) => boolean | Promise<boolean>, timeout?: number } | ((browserContext: BrowserContext) => boolean | Promise<boolean>)): Promise<BrowserContext>;++ /**+ * Emitted when JavaScript within the page calls one of console API methods, e.g. `console.log` or `console.dir`.+ *+ * The arguments passed into `console.log` and the page are available on the+ * [ConsoleMessage](https://playwright.dev/docs/api/class-consolemessage) event handler argument.+ *+ * **Usage**+ *+ * ```js+ * context.on('console', async msg => {+ * const values = [];+ * for (const arg of msg.args())+ * values.push(await arg.jsonValue());+ * console.log(...values);+ * });+ * await page.evaluate(() => console.log('hello', 5, { foo: 'bar' }));+ * ```+ *+ */+ waitForEvent(event: 'console', optionsOrPredicate?: { predicate?: (consoleMessage: ConsoleMessage) => boolean | Promise<boolean>, timeout?: number } | ((consoleMessage: ConsoleMessage) => boolean | Promise<boolean>)): Promise<ConsoleMessage>;++ /**+ * Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**+ * either [dialog.accept([promptText])](https://playwright.dev/docs/api/class-dialog#dialog-accept) or+ * [dialog.dismiss()](https://playwright.dev/docs/api/class-dialog#dialog-dismiss) the dialog - otherwise the page+ * will [freeze](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#never_blocking) waiting for the+ * dialog, and actions like click will never finish.+ *+ * **Usage**+ *+ * ```js+ * context.on('dialog', dialog => {+ * dialog.accept();+ * });+ * ```+ *+ * **NOTE** When no [page.on('dialog')](https://playwright.dev/docs/api/class-page#page-event-dialog) or+ * [browserContext.on('dialog')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-dialog)+ * listeners are present, all dialogs are automatically dismissed.+ *+ */+ waitForEvent(event: 'dialog', optionsOrPredicate?: { predicate?: (dialog: Dialog) => boolean | Promise<boolean>, timeout?: number } | ((dialog: Dialog) => boolean | Promise<boolean>)): Promise<Dialog>;++ /**+ * The event is emitted when a new Page is created in the BrowserContext. The page may still be loading. The event+ * will also fire for popup pages. See also+ * [page.on('popup')](https://playwright.dev/docs/api/class-page#page-event-popup) to receive events about popups+ * relevant to a specific page.+ *+ * The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a+ * popup with `window.open('http://example.com')`, this event will fire when the network request to+ * "http://example.com" is done and its response has started loading in the popup. If you would like to route/listen+ * to this network request, use+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * and+ * [browserContext.on('request')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request)+ * respectively instead of similar methods on the [Page](https://playwright.dev/docs/api/class-page).+ *+ * ```js+ * const newPagePromise = context.waitForEvent('page');+ * await page.getByText('open new page').click();+ * const newPage = await newPagePromise;+ * console.log(await newPage.evaluate('location.href'));+ * ```+ *+ * **NOTE** Use+ * [page.waitForLoadState([state, options])](https://playwright.dev/docs/api/class-page#page-wait-for-load-state) to+ * wait until the page gets to a particular state (you should not need it in most cases).+ *+ */+ waitForEvent(event: 'page', optionsOrPredicate?: { predicate?: (page: Page) => boolean | Promise<boolean>, timeout?: number } | ((page: Page) => boolean | Promise<boolean>)): Promise<Page>;++ /**+ * Emitted when a request is issued from any pages created through this context. The [request] object is read-only. To+ * only listen for requests from a particular page, use+ * [page.on('request')](https://playwright.dev/docs/api/class-page#page-event-request).+ *+ * In order to intercept and mutate requests, see+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route)+ * or [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route).+ */+ waitForEvent(event: 'request', optionsOrPredicate?: { predicate?: (request: Request) => boolean | Promise<boolean>, timeout?: number } | ((request: Request) => boolean | Promise<boolean>)): Promise<Request>;++ /**+ * Emitted when a request fails, for example by timing out. To only listen for failed requests from a particular page,+ * use [page.on('requestfailed')](https://playwright.dev/docs/api/class-page#page-event-request-failed).+ *+ * **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request+ * will complete with+ * [browserContext.on('requestfinished')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request-finished)+ * event and not with+ * [browserContext.on('requestfailed')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request-failed).+ *+ */+ waitForEvent(event: 'requestfailed', optionsOrPredicate?: { predicate?: (request: Request) => boolean | Promise<boolean>, timeout?: number } | ((request: Request) => boolean | Promise<boolean>)): Promise<Request>;++ /**+ * Emitted when a request finishes successfully after downloading the response body. For a successful response, the+ * sequence of events is `request`, `response` and `requestfinished`. To listen for successful requests from a+ * particular page, use+ * [page.on('requestfinished')](https://playwright.dev/docs/api/class-page#page-event-request-finished).+ */+ waitForEvent(event: 'requestfinished', optionsOrPredicate?: { predicate?: (request: Request) => boolean | Promise<boolean>, timeout?: number } | ((request: Request) => boolean | Promise<boolean>)): Promise<Request>;++ /**+ * Emitted when [response] status and headers are received for a request. For a successful response, the sequence of+ * events is `request`, `response` and `requestfinished`. To listen for response events from a particular page, use+ * [page.on('response')](https://playwright.dev/docs/api/class-page#page-event-response).+ */+ waitForEvent(event: 'response', optionsOrPredicate?: { predicate?: (response: Response) => boolean | Promise<boolean>, timeout?: number } | ((response: Response) => boolean | Promise<boolean>)): Promise<Response>;++ /**+ * **NOTE** Service workers are only supported on Chromium-based browsers.+ *+ * Emitted when new service worker is created in the context.+ */+ waitForEvent(event: 'serviceworker', optionsOrPredicate?: { predicate?: (worker: Worker) => boolean | Promise<boolean>, timeout?: number } | ((worker: Worker) => boolean | Promise<boolean>)): Promise<Worker>;++ /**+ * Emitted when exception is unhandled in any of the pages in this context. To listen for errors from a particular+ * page, use [page.on('pageerror')](https://playwright.dev/docs/api/class-page#page-event-page-error) instead.+ */+ waitForEvent(event: 'weberror', optionsOrPredicate?: { predicate?: (webError: WebError) => boolean | Promise<boolean>, timeout?: number } | ((webError: WebError) => boolean | Promise<boolean>)): Promise<WebError>;+++ /**+ * Playwright has ability to mock clock and passage of time.+ */+ clock: Clock;++ /**+ * API testing helper associated with this context. Requests made with this API will use context cookies.+ */+ request: APIRequestContext;++ tracing: Tracing;++ [Symbol.asyncDispose](): Promise<void>;+}++/**+ * A Browser is created via+ * [browserType.launch([options])](https://playwright.dev/docs/api/class-browsertype#browser-type-launch). An example+ * of using a [Browser](https://playwright.dev/docs/api/class-browser) to create a+ * [Page](https://playwright.dev/docs/api/class-page):+ *+ * ```js+ * const { firefox } = require('playwright'); // Or 'chromium' or 'webkit'.+ *+ * (async () => {+ * const browser = await firefox.launch();+ * const page = await browser.newPage();+ * await page.goto('https://example.com');+ * await browser.close();+ * })();+ * ```+ *+ */+export interface Browser {+ /**+ * Removes all the listeners of the given type (or all registered listeners if no type given). Allows to wait for+ * async listeners to complete or to ignore subsequent errors from these listeners.+ * @param type+ * @param options+ */+ removeAllListeners(type?: string): this;+ /**+ * Removes all the listeners of the given type (or all registered listeners if no type given). Allows to wait for+ * async listeners to complete or to ignore subsequent errors from these listeners.+ * @param type+ * @param options+ */+ removeAllListeners(type: string | undefined, options: {+ /**+ * Specifies whether to wait for already running listeners and what to do if they throw errors:+ * - `'default'` - do not wait for current listener calls (if any) to finish, if the listener throws, it may result in unhandled error+ * - `'wait'` - wait for current listener calls (if any) to finish+ * - `'ignoreErrors'` - do not wait for current listener calls (if any) to finish, all errors thrown by the listeners after removal are silently caught+ */+ behavior?: 'wait'|'ignoreErrors'|'default'+ }): Promise<void>;+ /**+ * Emitted when Browser gets disconnected from the browser application. This might happen because of one of the+ * following:+ * - Browser application is closed or crashed.+ * - The [browser.close([options])](https://playwright.dev/docs/api/class-browser#browser-close) method was called.+ */+ on(event: 'disconnected', listener: (browser: Browser) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'disconnected', listener: (browser: Browser) => any): this;++ /**+ * Emitted when Browser gets disconnected from the browser application. This might happen because of one of the+ * following:+ * - Browser application is closed or crashed.+ * - The [browser.close([options])](https://playwright.dev/docs/api/class-browser#browser-close) method was called.+ */+ addListener(event: 'disconnected', listener: (browser: Browser) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'disconnected', listener: (browser: Browser) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'disconnected', listener: (browser: Browser) => any): this;++ /**+ * Emitted when Browser gets disconnected from the browser application. This might happen because of one of the+ * following:+ * - Browser application is closed or crashed.+ * - The [browser.close([options])](https://playwright.dev/docs/api/class-browser#browser-close) method was called.+ */+ prependListener(event: 'disconnected', listener: (browser: Browser) => any): this;++ /**+ * Get the browser type (chromium, firefox or webkit) that the browser belongs to.+ */+ browserType(): BrowserType;++ /**+ * In case this browser is obtained using+ * [browserType.launch([options])](https://playwright.dev/docs/api/class-browsertype#browser-type-launch), closes the+ * browser and all of its pages (if any were opened).+ *+ * In case this browser is connected to, clears all created contexts belonging to this browser and disconnects from+ * the browser server.+ *+ * **NOTE** This is similar to force-quitting the browser. To close pages gracefully and ensure you receive page close+ * events, call+ * [browserContext.close([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-close) on+ * any [BrowserContext](https://playwright.dev/docs/api/class-browsercontext) instances you explicitly created earlier+ * using [browser.newContext([options])](https://playwright.dev/docs/api/class-browser#browser-new-context) **before**+ * calling [browser.close([options])](https://playwright.dev/docs/api/class-browser#browser-close).+ *+ * The [Browser](https://playwright.dev/docs/api/class-browser) object itself is considered to be disposed and cannot+ * be used anymore.+ * @param options+ */+ close(options?: {+ /**+ * The reason to be reported to the operations interrupted by the browser closure.+ */+ reason?: string;+ }): Promise<void>;++ /**+ * Returns an array of all open browser contexts. In a newly created browser, this will return zero browser contexts.+ *+ * **Usage**+ *+ * ```js+ * const browser = await pw.webkit.launch();+ * console.log(browser.contexts().length); // prints `0`+ *+ * const context = await browser.newContext();+ * console.log(browser.contexts().length); // prints `1`+ * ```+ *+ */+ contexts(): Array<BrowserContext>;++ /**+ * Indicates that the browser is connected.+ */+ isConnected(): boolean;++ /**+ * **NOTE** CDP Sessions are only supported on Chromium-based browsers.+ *+ * Returns the newly created browser session.+ */+ newBrowserCDPSession(): Promise<CDPSession>;++ /**+ * Creates a new browser context. It won't share cookies/cache with other browser contexts.+ *+ * **NOTE** If directly using this method to create+ * [BrowserContext](https://playwright.dev/docs/api/class-browsercontext)s, it is best practice to explicitly close+ * the returned context via+ * [browserContext.close([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-close) when+ * your code is done with the [BrowserContext](https://playwright.dev/docs/api/class-browsercontext), and before+ * calling [browser.close([options])](https://playwright.dev/docs/api/class-browser#browser-close). This will ensure+ * the `context` is closed gracefully and any artifacts—like HARs and videos—are fully flushed and saved.+ *+ * **Usage**+ *+ * ```js+ * (async () => {+ * const browser = await playwright.firefox.launch(); // Or 'chromium' or 'webkit'.+ * // Create a new incognito browser context.+ * const context = await browser.newContext();+ * // Create a new page in a pristine context.+ * const page = await context.newPage();+ * await page.goto('https://example.com');+ *+ * // Gracefully close up everything+ * await context.close();+ * await browser.close();+ * })();+ * ```+ *+ * @param options+ */+ newContext(options?: BrowserContextOptions): Promise<BrowserContext>;++ /**+ * Creates a new page in a new browser context. Closing this page will close the context as well.+ *+ * This is a convenience API that should only be used for the single-page scenarios and short snippets. Production+ * code and testing frameworks should explicitly create+ * [browser.newContext([options])](https://playwright.dev/docs/api/class-browser#browser-new-context) followed by the+ * [browserContext.newPage()](https://playwright.dev/docs/api/class-browsercontext#browser-context-new-page) to+ * control their exact life times.+ * @param options+ */+ newPage(options?: {+ /**+ * Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.+ */+ acceptDownloads?: boolean;++ /**+ * An object containing an option to throw an error when API request returns status codes other than 2xx and 3xx. By+ * default, response object is returned for all status codes.+ */+ apiRequestFailsOnErrorStatus?: boolean;++ /**+ * When using [page.goto(url[, options])](https://playwright.dev/docs/api/class-page#page-goto),+ * [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route),+ * [page.waitForURL(url[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-url),+ * [page.waitForRequest(urlOrPredicate[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-request),+ * or+ * [page.waitForResponse(urlOrPredicate[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-response)+ * it takes the base URL in consideration by using the+ * [`URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor for building the corresponding URL.+ * Unset by default. Examples:+ * - baseURL: `http://localhost:3000` and navigating to `/bar.html` results in `http://localhost:3000/bar.html`+ * - baseURL: `http://localhost:3000/foo/` and navigating to `./bar.html` results in+ * `http://localhost:3000/foo/bar.html`+ * - baseURL: `http://localhost:3000/foo` (without trailing slash) and navigating to `./bar.html` results in+ * `http://localhost:3000/bar.html`+ */+ baseURL?: string;++ /**+ * Toggles bypassing page's Content-Security-Policy. Defaults to `false`.+ */+ bypassCSP?: boolean;++ /**+ * TLS Client Authentication allows the server to request a client certificate and verify it.+ *+ * **Details**+ *+ * An array of client certificates to be used. Each certificate object must have either both `certPath` and `keyPath`,+ * a single `pfxPath`, or their corresponding direct value equivalents (`cert` and `key`, or `pfx`). Optionally,+ * `passphrase` property should be provided if the certificate is encrypted. The `origin` property should be provided+ * with an exact match to the request origin that the certificate is valid for.+ *+ * **NOTE** When using WebKit on macOS, accessing `localhost` will not pick up client certificates. You can make it+ * work by replacing `localhost` with `local.playwright`.+ *+ */+ clientCertificates?: Array<{+ /**+ * Exact origin that the certificate is valid for. Origin includes `https` protocol, a hostname and optionally a port.+ */+ origin: string;++ /**+ * Path to the file with the certificate in PEM format.+ */+ certPath?: string;++ /**+ * Direct value of the certificate in PEM format.+ */+ cert?: Buffer;++ /**+ * Path to the file with the private key in PEM format.+ */+ keyPath?: string;++ /**+ * Direct value of the private key in PEM format.+ */+ key?: Buffer;++ /**+ * Path to the PFX or PKCS12 encoded private key and certificate chain.+ */+ pfxPath?: string;++ /**+ * Direct value of the PFX or PKCS12 encoded private key and certificate chain.+ */+ pfx?: Buffer;++ /**+ * Passphrase for the private key (PEM or PFX).+ */+ passphrase?: string;+ }>;++ /**+ * Emulates [prefers-colors-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)+ * media feature, supported values are `'light'` and `'dark'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'light'`.+ */+ colorScheme?: null|"light"|"dark"|"no-preference";++ /**+ * Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'no-preference'`.+ */+ contrast?: null|"no-preference"|"more";++ /**+ * Specify device scale factor (can be thought of as dpr). Defaults to `1`. Learn more about+ * [emulating devices with device scale factor](https://playwright.dev/docs/emulation#devices).+ */+ deviceScaleFactor?: number;++ /**+ * An object containing additional HTTP headers to be sent with every request. Defaults to none.+ */+ extraHTTPHeaders?: { [key: string]: string; };++ /**+ * Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'none'`.+ */+ forcedColors?: null|"active"|"none";++ geolocation?: {+ /**+ * Latitude between -90 and 90.+ */+ latitude: number;++ /**+ * Longitude between -180 and 180.+ */+ longitude: number;++ /**+ * Non-negative accuracy value. Defaults to `0`.+ */+ accuracy?: number;+ };++ /**+ * Specifies if viewport supports touch events. Defaults to false. Learn more about+ * [mobile emulation](https://playwright.dev/docs/emulation#devices).+ */+ hasTouch?: boolean;++ /**+ * Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If no+ * origin is specified, the username and password are sent to any servers upon unauthorized responses.+ */+ httpCredentials?: {+ username: string;++ password: string;++ /**+ * Restrain sending http credentials on specific origin (scheme://host:port).+ */+ origin?: string;++ /**+ * This option only applies to the requests sent from corresponding+ * [APIRequestContext](https://playwright.dev/docs/api/class-apirequestcontext) and does not affect requests sent from+ * the browser. `'always'` - `Authorization` header with basic authentication credentials will be sent with the each+ * API request. `'unauthorized` - the credentials are only sent when 401 (Unauthorized) response with+ * `WWW-Authenticate` header is received. Defaults to `'unauthorized'`.+ */+ send?: "unauthorized"|"always";+ };++ /**+ * Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.+ */+ ignoreHTTPSErrors?: boolean;++ /**+ * Whether the `meta viewport` tag is taken into account and touch events are enabled. isMobile is a part of device,+ * so you don't actually need to set it manually. Defaults to `false` and is not supported in Firefox. Learn more+ * about [mobile emulation](https://playwright.dev/docs/emulation#ismobile).+ */+ isMobile?: boolean;++ /**+ * Whether or not to enable JavaScript in the context. Defaults to `true`. Learn more about+ * [disabling JavaScript](https://playwright.dev/docs/emulation#javascript-enabled).+ */+ javaScriptEnabled?: boolean;++ /**+ * Specify user locale, for example `en-GB`, `de-DE`, etc. Locale will affect `navigator.language` value,+ * `Accept-Language` request header value as well as number and date formatting rules. Defaults to the system default+ * locale. Learn more about emulation in our [emulation guide](https://playwright.dev/docs/emulation#locale--timezone).+ */+ locale?: string;++ /**+ * Logger sink for Playwright logging.+ */+ logger?: Logger;++ /**+ * Whether to emulate network being offline. Defaults to `false`. Learn more about+ * [network emulation](https://playwright.dev/docs/emulation#offline).+ */+ offline?: boolean;++ /**+ * A list of permissions to grant to all pages in this context. See+ * [browserContext.grantPermissions(permissions[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-grant-permissions)+ * for more details. Defaults to none.+ */+ permissions?: Array<string>;++ /**+ * Network proxy settings to use with this context. Defaults to none.+ */+ proxy?: {+ /**+ * Proxy to be used for all requests. HTTP and SOCKS proxies are supported, for example `http://myproxy.com:3128` or+ * `socks5://myproxy.com:3128`. Short form `myproxy.com:3128` is considered an HTTP proxy.+ */+ server: string;++ /**+ * Optional comma-separated domains to bypass proxy, for example `".com, chromium.org, .domain.com"`.+ */+ bypass?: string;++ /**+ * Optional username to use if HTTP proxy requires authentication.+ */+ username?: string;++ /**+ * Optional password to use if HTTP proxy requires authentication.+ */+ password?: string;+ };++ /**+ * Enables [HAR](http://www.softwareishard.com/blog/har-12-spec) recording for all pages into `recordHar.path` file.+ * If not specified, the HAR is not recorded. Make sure to await+ * [browserContext.close([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-close) for+ * the HAR to be saved.+ */+ recordHar?: {+ /**+ * Optional setting to control whether to omit request content from the HAR. Defaults to `false`. Deprecated, use+ * `content` policy instead.+ */+ omitContent?: boolean;++ /**+ * Optional setting to control resource content management. If `omit` is specified, content is not persisted. If+ * `attach` is specified, resources are persisted as separate files or entries in the ZIP archive. If `embed` is+ * specified, content is stored inline the HAR file as per HAR specification. Defaults to `attach` for `.zip` output+ * files and to `embed` for all other file extensions.+ */+ content?: "omit"|"embed"|"attach";++ /**+ * Path on the filesystem to write the HAR file to. If the file name ends with `.zip`, `content: 'attach'` is used by+ * default.+ */+ path: string;++ /**+ * When set to `minimal`, only record information necessary for routing from HAR. This omits sizes, timing, page,+ * cookies, security and other types of HAR information that are not used when replaying from HAR. Defaults to `full`.+ */+ mode?: "full"|"minimal";++ /**+ * A glob or regex pattern to filter requests that are stored in the HAR. When a+ * [`baseURL`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-base-url) via the context+ * options was provided and the passed URL is a path, it gets merged via the+ * [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor. Defaults to none.+ */+ urlFilter?: string|RegExp;+ };++ /**+ * Enables video recording for all pages into `recordVideo.dir` directory. If not specified videos are not recorded.+ * Make sure to await+ * [browserContext.close([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-close) for+ * videos to be saved.+ */+ recordVideo?: {+ /**+ * Path to the directory to put videos into.+ */+ dir: string;++ /**+ * Optional dimensions of the recorded videos. If not specified the size will be equal to `viewport` scaled down to+ * fit into 800x800. If `viewport` is not configured explicitly the video size defaults to 800x450. Actual picture of+ * each page will be scaled down if necessary to fit the specified size.+ */+ size?: {+ /**+ * Video frame width.+ */+ width: number;++ /**+ * Video frame height.+ */+ height: number;+ };+ };++ /**+ * Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'no-preference'`.+ */+ reducedMotion?: null|"reduce"|"no-preference";++ /**+ * Emulates consistent window screen size available inside web page via `window.screen`. Is only used when the+ * [`viewport`](https://playwright.dev/docs/api/class-browser#browser-new-page-option-viewport) is set.+ */+ screen?: {+ /**+ * page width in pixels.+ */+ width: number;++ /**+ * page height in pixels.+ */+ height: number;+ };++ /**+ * Whether to allow sites to register Service workers. Defaults to `'allow'`.+ * - `'allow'`: [Service Workers](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) can be+ * registered.+ * - `'block'`: Playwright will block all registration of Service Workers.+ */+ serviceWorkers?: "allow"|"block";++ /**+ * Learn more about [storage state and auth](https://playwright.dev/docs/auth).+ *+ * Populates context with given storage state. This option can be used to initialize context with logged-in+ * information obtained via+ * [browserContext.storageState([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-storage-state).+ */+ storageState?: string|{+ /**+ * Cookies to set for context+ */+ cookies: Array<{+ name: string;++ value: string;++ /**+ * Domain and path are required. For the cookie to apply to all subdomains as well, prefix domain with a dot, like+ * this: ".example.com"+ */+ domain: string;++ /**+ * Domain and path are required+ */+ path: string;++ /**+ * Unix time in seconds.+ */+ expires: number;++ httpOnly: boolean;++ secure: boolean;++ /**+ * sameSite flag+ */+ sameSite: "Strict"|"Lax"|"None";+ }>;++ origins: Array<{+ origin: string;++ /**+ * localStorage to set for context+ */+ localStorage: Array<{+ name: string;++ value: string;+ }>;++ /**+ * indexedDB to set for context+ */+ indexedDB?: Array<{+ /**+ * database name+ */+ name: string;++ /**+ * database version+ */+ version: number;++ stores: Array<{+ name: string;++ keyPath?: string;++ keyPathArray?: Array<string>;++ autoIncrement: boolean;++ indexes: Array<{+ name: string;++ keyPath?: string;++ keyPathArray?: Array<string>;++ unique: boolean;++ multiEntry: boolean;+ }>;++ records: Array<{+ key?: Object;++ /**+ * if `key` is not JSON-serializable, this contains an encoded version that preserves types.+ */+ keyEncoded?: Object;++ value?: Object;++ /**+ * if `value` is not JSON-serializable, this contains an encoded version that preserves types.+ */+ valueEncoded?: Object;+ }>;+ }>;+ }>;+ }>;+ };++ /**+ * If set to true, enables strict selectors mode for this context. In the strict selectors mode all operations on+ * selectors that imply single target DOM element will throw when more than one element matches the selector. This+ * option does not affect any Locator APIs (Locators are always strict). Defaults to `false`. See+ * [Locator](https://playwright.dev/docs/api/class-locator) to learn more about the strict mode.+ */+ strictSelectors?: boolean;++ /**+ * Changes the timezone of the context. See+ * [ICU's metaZones.txt](https://cs.chromium.org/chromium/src/third_party/icu/source/data/misc/metaZones.txt?rcl=faee8bc70570192d82d2978a71e2a615788597d1)+ * for a list of supported timezone IDs. Defaults to the system timezone.+ */+ timezoneId?: string;++ /**+ * Specific user agent to use in this context.+ */+ userAgent?: string;++ /**+ * @deprecated Use [`recordVideo`](https://playwright.dev/docs/api/class-browser#browser-new-page-option-record-video) instead.+ */+ videoSize?: {+ /**+ * Video frame width.+ */+ width: number;++ /**+ * Video frame height.+ */+ height: number;+ };++ /**+ * @deprecated Use [`recordVideo`](https://playwright.dev/docs/api/class-browser#browser-new-page-option-record-video) instead.+ */+ videosPath?: string;++ /**+ * Emulates consistent viewport for each page. Defaults to an 1280x720 viewport. Use `null` to disable the consistent+ * viewport emulation. Learn more about [viewport emulation](https://playwright.dev/docs/emulation#viewport).+ *+ * **NOTE** The `null` value opts out from the default presets, makes viewport depend on the host window size defined+ * by the operating system. It makes the execution of the tests non-deterministic.+ *+ */+ viewport?: null|{+ /**+ * page width in pixels.+ */+ width: number;++ /**+ * page height in pixels.+ */+ height: number;+ };+ }): Promise<Page>;++ /**+ * **NOTE** This API controls+ * [Chromium Tracing](https://www.chromium.org/developers/how-tos/trace-event-profiling-tool) which is a low-level+ * chromium-specific debugging tool. API to control [Playwright Tracing](https://playwright.dev/docs/trace-viewer) could be found+ * [here](https://playwright.dev/docs/api/class-tracing).+ *+ * You can use+ * [browser.startTracing([page, options])](https://playwright.dev/docs/api/class-browser#browser-start-tracing) and+ * [browser.stopTracing()](https://playwright.dev/docs/api/class-browser#browser-stop-tracing) to create a trace file+ * that can be opened in Chrome DevTools performance panel.+ *+ * **Usage**+ *+ * ```js+ * await browser.startTracing(page, { path: 'trace.json' });+ * await page.goto('https://www.google.com');+ * await browser.stopTracing();+ * ```+ *+ * @param page Optional, if specified, tracing includes screenshots of the given page.+ * @param options+ */+ startTracing(page?: Page, options?: {+ /**+ * specify custom categories to use instead of default.+ */+ categories?: Array<string>;++ /**+ * A path to write the trace file to.+ */+ path?: string;++ /**+ * captures screenshots in the trace.+ */+ screenshots?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** This API controls+ * [Chromium Tracing](https://www.chromium.org/developers/how-tos/trace-event-profiling-tool) which is a low-level+ * chromium-specific debugging tool. API to control [Playwright Tracing](https://playwright.dev/docs/trace-viewer) could be found+ * [here](https://playwright.dev/docs/api/class-tracing).+ *+ * Returns the buffer with trace data.+ */+ stopTracing(): Promise<Buffer>;++ /**+ * Returns the browser version.+ */+ version(): string;++ [Symbol.asyncDispose](): Promise<void>;+}++/**+ * The Worker class represents a [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API).+ * `worker` event is emitted on the page object to signal a worker creation. `close` event is emitted on the worker+ * object when the worker is gone.+ *+ * ```js+ * page.on('worker', worker => {+ * console.log('Worker created: ' + worker.url());+ * worker.on('close', worker => console.log('Worker destroyed: ' + worker.url()));+ * });+ *+ * console.log('Current workers:');+ * for (const worker of page.workers())+ * console.log(' ' + worker.url());+ * ```+ *+ */+export interface Worker {+ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-worker#worker-evaluate-option-expression).+ *+ * If the function passed to the+ * [worker.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate) returns a+ * [Promise], then+ * [worker.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate) would wait for+ * the promise to resolve and return its value.+ *+ * If the function passed to the+ * [worker.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate) returns a+ * non-[Serializable] value, then+ * [worker.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate) returns+ * `undefined`. Playwright also supports transferring some additional values that are not serializable by `JSON`:+ * `-0`, `NaN`, `Infinity`, `-Infinity`.+ * @param pageFunction Function to be evaluated in the worker context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-worker#worker-evaluate-option-expression).+ */+ evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg): Promise<R>;+ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-worker#worker-evaluate-option-expression).+ *+ * If the function passed to the+ * [worker.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate) returns a+ * [Promise], then+ * [worker.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate) would wait for+ * the promise to resolve and return its value.+ *+ * If the function passed to the+ * [worker.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate) returns a+ * non-[Serializable] value, then+ * [worker.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate) returns+ * `undefined`. Playwright also supports transferring some additional values that are not serializable by `JSON`:+ * `-0`, `NaN`, `Infinity`, `-Infinity`.+ * @param pageFunction Function to be evaluated in the worker context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-worker#worker-evaluate-option-expression).+ */+ evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any): Promise<R>;++ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-worker#worker-evaluate-handle-option-expression) as a+ * [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * The only difference between+ * [worker.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate) and+ * [worker.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate-handle)+ * is that+ * [worker.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate-handle)+ * returns [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * If the function passed to the+ * [worker.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate-handle)+ * returns a [Promise], then+ * [worker.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate-handle)+ * would wait for the promise to resolve and return its value.+ * @param pageFunction Function to be evaluated in the worker context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-worker#worker-evaluate-handle-option-expression).+ */+ evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg): Promise<SmartHandle<R>>;+ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-worker#worker-evaluate-handle-option-expression) as a+ * [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * The only difference between+ * [worker.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate) and+ * [worker.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate-handle)+ * is that+ * [worker.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate-handle)+ * returns [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * If the function passed to the+ * [worker.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate-handle)+ * returns a [Promise], then+ * [worker.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-worker#worker-evaluate-handle)+ * would wait for the promise to resolve and return its value.+ * @param pageFunction Function to be evaluated in the worker context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-worker#worker-evaluate-handle-option-expression).+ */+ evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any): Promise<SmartHandle<R>>;+ /**+ * Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is+ * terminated.+ */+ on(event: 'close', listener: (worker: Worker) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'close', listener: (worker: Worker) => any): this;++ /**+ * Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is+ * terminated.+ */+ addListener(event: 'close', listener: (worker: Worker) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'close', listener: (worker: Worker) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'close', listener: (worker: Worker) => any): this;++ /**+ * Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is+ * terminated.+ */+ prependListener(event: 'close', listener: (worker: Worker) => any): this;++ url(): string;+}++/**+ * JSHandle represents an in-page JavaScript object. JSHandles can be created with the+ * [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle) method.+ *+ * ```js+ * const windowHandle = await page.evaluateHandle(() => window);+ * // ...+ * ```+ *+ * JSHandle prevents the referenced JavaScript object being garbage collected unless the handle is exposed with+ * [jsHandle.dispose()](https://playwright.dev/docs/api/class-jshandle#js-handle-dispose). JSHandles are auto-disposed+ * when their origin frame gets navigated or the parent context gets destroyed.+ *+ * JSHandle instances can be used as an argument in+ * [page.$eval(selector, pageFunction[, arg, options])](https://playwright.dev/docs/api/class-page#page-eval-on-selector),+ * [page.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate) and+ * [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle)+ * methods.+ */+export interface JSHandle<T = any> {+ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression).+ *+ * This method passes this handle as the first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression).+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression)+ * returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const tweetHandle = await page.$('.tweet .retweets');+ * expect(await tweetHandle.evaluate(node => node.innerText)).toBe('10 retweets');+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression).+ */+ evaluate<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg): Promise<R>;+ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression).+ *+ * This method passes this handle as the first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression).+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression)+ * returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const tweetHandle = await page.$('.tweet .retweets');+ * expect(await tweetHandle.evaluate(node => node.innerText)).toBe('10 retweets');+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression).+ */+ evaluate<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any): Promise<R>;++ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle-option-expression)+ * as a [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * This method passes this handle as the first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle-option-expression).+ *+ * The only difference between `jsHandle.evaluate` and `jsHandle.evaluateHandle` is that `jsHandle.evaluateHandle`+ * returns [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * If the function passed to the `jsHandle.evaluateHandle` returns a [Promise], then `jsHandle.evaluateHandle` would+ * wait for the promise to resolve and return its value.+ *+ * See [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle) for+ * more details.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle-option-expression).+ */+ evaluateHandle<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg): Promise<SmartHandle<R>>;+ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle-option-expression)+ * as a [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * This method passes this handle as the first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle-option-expression).+ *+ * The only difference between `jsHandle.evaluate` and `jsHandle.evaluateHandle` is that `jsHandle.evaluateHandle`+ * returns [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * If the function passed to the `jsHandle.evaluateHandle` returns a [Promise], then `jsHandle.evaluateHandle` would+ * wait for the promise to resolve and return its value.+ *+ * See [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle) for+ * more details.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle-option-expression).+ */+ evaluateHandle<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any): Promise<SmartHandle<R>>;++ /**+ * Returns a JSON representation of the object. If the object has a `toJSON` function, it **will not be called**.+ *+ * **NOTE** The method will return an empty JSON object if the referenced object is not stringifiable. It will throw+ * an error if the object has circular references.+ *+ */+ jsonValue(): Promise<T>;+ /**+ * Returns either `null` or the object handle itself, if the object handle is an instance of+ * [ElementHandle](https://playwright.dev/docs/api/class-elementhandle).+ */+ asElement(): T extends Node ? ElementHandle<T> : null;+ /**+ * The `jsHandle.dispose` method stops referencing the element handle.+ */+ dispose(): Promise<void>;++ /**+ * The method returns a map with **own property names** as keys and JSHandle instances for the property values.+ *+ * **Usage**+ *+ * ```js+ * const handle = await page.evaluateHandle(() => ({ window, document }));+ * const properties = await handle.getProperties();+ * const windowHandle = properties.get('window');+ * const documentHandle = properties.get('document');+ * await handle.dispose();+ * ```+ *+ */+ getProperties(): Promise<Map<string, JSHandle>>;++ /**+ * Fetches a single property from the referenced object.+ * @param propertyName property to get+ */+ getProperty(propertyName: string): Promise<JSHandle>;++ [Symbol.asyncDispose](): Promise<void>;+}++/**+ * - extends: [JSHandle](https://playwright.dev/docs/api/class-jshandle)+ *+ * ElementHandle represents an in-page DOM element. ElementHandles can be created with the+ * [page.$(selector[, options])](https://playwright.dev/docs/api/class-page#page-query-selector) method.+ *+ * **NOTE** The use of ElementHandle is discouraged, use [Locator](https://playwright.dev/docs/api/class-locator)+ * objects and web-first assertions instead.+ *+ * ```js+ * const hrefElement = await page.$('a');+ * await hrefElement.click();+ * ```+ *+ * ElementHandle prevents DOM element from garbage collection unless the handle is disposed with+ * [jsHandle.dispose()](https://playwright.dev/docs/api/class-jshandle#js-handle-dispose). ElementHandles are+ * auto-disposed when their origin frame gets navigated.+ *+ * ElementHandle instances can be used as an argument in+ * [page.$eval(selector, pageFunction[, arg, options])](https://playwright.dev/docs/api/class-page#page-eval-on-selector)+ * and [page.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate) methods.+ *+ * The difference between the [Locator](https://playwright.dev/docs/api/class-locator) and ElementHandle is that the+ * ElementHandle points to a particular element, while [Locator](https://playwright.dev/docs/api/class-locator)+ * captures the logic of how to retrieve an element.+ *+ * In the example below, handle points to a particular DOM element on page. If that element changes text or is used by+ * React to render an entirely different component, handle is still pointing to that very DOM element. This can lead+ * to unexpected behaviors.+ *+ * ```js+ * const handle = await page.$('text=Submit');+ * // ...+ * await handle.hover();+ * await handle.click();+ * ```+ *+ * With the locator, every time the `element` is used, up-to-date DOM element is located in the page using the+ * selector. So in the snippet below, underlying DOM element is going to be located twice.+ *+ * ```js+ * const locator = page.getByText('Submit');+ * // ...+ * await locator.hover();+ * await locator.click();+ * ```+ *+ */+export interface ElementHandle<T=Node> extends JSHandle<T> {+ /**+ * **NOTE** Use locator-based [page.locator(selector[, options])](https://playwright.dev/docs/api/class-page#page-locator)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * The method finds an element matching the specified selector in the `ElementHandle`'s subtree. If no elements match+ * the selector, returns `null`.+ * @param selector A selector to query for.+ */+ $<K extends keyof HTMLElementTagNameMap>(selector: K, options?: { strict: boolean }): Promise<ElementHandleForTag<K> | null>;+ /**+ * **NOTE** Use locator-based [page.locator(selector[, options])](https://playwright.dev/docs/api/class-page#page-locator)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * The method finds an element matching the specified selector in the `ElementHandle`'s subtree. If no elements match+ * the selector, returns `null`.+ * @param selector A selector to query for.+ */+ $(selector: string, options?: { strict: boolean }): Promise<ElementHandle<SVGElement | HTMLElement> | null>;++ /**+ * **NOTE** Use locator-based [page.locator(selector[, options])](https://playwright.dev/docs/api/class-page#page-locator)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * The method finds all elements matching the specified selector in the `ElementHandle`s subtree. If no elements match+ * the selector, returns empty array.+ * @param selector A selector to query for.+ */+ $$<K extends keyof HTMLElementTagNameMap>(selector: K): Promise<ElementHandleForTag<K>[]>;+ /**+ * **NOTE** Use locator-based [page.locator(selector[, options])](https://playwright.dev/docs/api/class-page#page-locator)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * The method finds all elements matching the specified selector in the `ElementHandle`s subtree. If no elements match+ * the selector, returns empty array.+ * @param selector A selector to query for.+ */+ $$(selector: string): Promise<ElementHandle<SVGElement | HTMLElement>[]>;++ /**+ * **NOTE** This method does not wait for the element to pass actionability checks and therefore can lead to the flaky tests.+ * Use+ * [locator.evaluate(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods or web-first assertions instead.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression).+ *+ * The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a+ * first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression).+ * If no elements match the selector, the method throws an error.+ *+ * If+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression)+ * returns a [Promise], then+ * [elementHandle.$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const tweetHandle = await page.$('.tweet');+ * expect(await tweetHandle.$eval('.like', node => node.innerText)).toBe('100');+ * expect(await tweetHandle.$eval('.retweets', node => node.innerText)).toBe('10');+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression).+ */+ $eval<K extends keyof HTMLElementTagNameMap, R, Arg>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K], Arg, R>, arg: Arg): Promise<R>;+ /**+ * **NOTE** This method does not wait for the element to pass actionability checks and therefore can lead to the flaky tests.+ * Use+ * [locator.evaluate(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods or web-first assertions instead.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression).+ *+ * The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a+ * first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression).+ * If no elements match the selector, the method throws an error.+ *+ * If+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression)+ * returns a [Promise], then+ * [elementHandle.$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const tweetHandle = await page.$('.tweet');+ * expect(await tweetHandle.$eval('.like', node => node.innerText)).toBe('100');+ * expect(await tweetHandle.$eval('.retweets', node => node.innerText)).toBe('10');+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression).+ */+ $eval<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E, Arg, R>, arg: Arg): Promise<R>;+ /**+ * **NOTE** This method does not wait for the element to pass actionability checks and therefore can lead to the flaky tests.+ * Use+ * [locator.evaluate(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods or web-first assertions instead.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression).+ *+ * The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a+ * first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression).+ * If no elements match the selector, the method throws an error.+ *+ * If+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression)+ * returns a [Promise], then+ * [elementHandle.$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const tweetHandle = await page.$('.tweet');+ * expect(await tweetHandle.$eval('.like', node => node.innerText)).toBe('100');+ * expect(await tweetHandle.$eval('.retweets', node => node.innerText)).toBe('10');+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression).+ */+ $eval<K extends keyof HTMLElementTagNameMap, R>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K], void, R>, arg?: any): Promise<R>;+ /**+ * **NOTE** This method does not wait for the element to pass actionability checks and therefore can lead to the flaky tests.+ * Use+ * [locator.evaluate(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods or web-first assertions instead.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression).+ *+ * The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a+ * first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression).+ * If no elements match the selector, the method throws an error.+ *+ * If+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression)+ * returns a [Promise], then+ * [elementHandle.$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```js+ * const tweetHandle = await page.$('.tweet');+ * expect(await tweetHandle.$eval('.like', node => node.innerText)).toBe('100');+ * expect(await tweetHandle.$eval('.retweets', node => node.innerText)).toBe('10');+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-option-expression).+ */+ $eval<R, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E, void, R>, arg?: any): Promise<R>;++ /**+ * **NOTE** In most cases,+ * [locator.evaluateAll(pageFunction[, arg])](https://playwright.dev/docs/api/class-locator#locator-evaluate-all),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods and web-first assertions do a better+ * job.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression).+ *+ * The method finds all elements matching the specified selector in the `ElementHandle`'s subtree and passes an array+ * of matched elements as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression).+ *+ * If+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression)+ * returns a [Promise], then+ * [elementHandle.$$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```html+ * <div class="feed">+ * <div class="tweet">Hello!</div>+ * <div class="tweet">Hi!</div>+ * </div>+ * ```+ *+ * ```js+ * const feedHandle = await page.$('.feed');+ * expect(await feedHandle.$$eval('.tweet', nodes =>+ * nodes.map(n => n.innerText))).toEqual(['Hello!', 'Hi!'],+ * );+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression).+ */+ $$eval<K extends keyof HTMLElementTagNameMap, R, Arg>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K][], Arg, R>, arg: Arg): Promise<R>;+ /**+ * **NOTE** In most cases,+ * [locator.evaluateAll(pageFunction[, arg])](https://playwright.dev/docs/api/class-locator#locator-evaluate-all),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods and web-first assertions do a better+ * job.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression).+ *+ * The method finds all elements matching the specified selector in the `ElementHandle`'s subtree and passes an array+ * of matched elements as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression).+ *+ * If+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression)+ * returns a [Promise], then+ * [elementHandle.$$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```html+ * <div class="feed">+ * <div class="tweet">Hello!</div>+ * <div class="tweet">Hi!</div>+ * </div>+ * ```+ *+ * ```js+ * const feedHandle = await page.$('.feed');+ * expect(await feedHandle.$$eval('.tweet', nodes =>+ * nodes.map(n => n.innerText))).toEqual(['Hello!', 'Hi!'],+ * );+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression).+ */+ $$eval<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E[], Arg, R>, arg: Arg): Promise<R>;+ /**+ * **NOTE** In most cases,+ * [locator.evaluateAll(pageFunction[, arg])](https://playwright.dev/docs/api/class-locator#locator-evaluate-all),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods and web-first assertions do a better+ * job.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression).+ *+ * The method finds all elements matching the specified selector in the `ElementHandle`'s subtree and passes an array+ * of matched elements as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression).+ *+ * If+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression)+ * returns a [Promise], then+ * [elementHandle.$$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```html+ * <div class="feed">+ * <div class="tweet">Hello!</div>+ * <div class="tweet">Hi!</div>+ * </div>+ * ```+ *+ * ```js+ * const feedHandle = await page.$('.feed');+ * expect(await feedHandle.$$eval('.tweet', nodes =>+ * nodes.map(n => n.innerText))).toEqual(['Hello!', 'Hi!'],+ * );+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression).+ */+ $$eval<K extends keyof HTMLElementTagNameMap, R>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K][], void, R>, arg?: any): Promise<R>;+ /**+ * **NOTE** In most cases,+ * [locator.evaluateAll(pageFunction[, arg])](https://playwright.dev/docs/api/class-locator#locator-evaluate-all),+ * other [Locator](https://playwright.dev/docs/api/class-locator) helper methods and web-first assertions do a better+ * job.+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression).+ *+ * The method finds all elements matching the specified selector in the `ElementHandle`'s subtree and passes an array+ * of matched elements as a first argument to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression).+ *+ * If+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression)+ * returns a [Promise], then+ * [elementHandle.$$eval(selector, pageFunction[, arg])](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all)+ * would wait for the promise to resolve and return its value.+ *+ * **Usage**+ *+ * ```html+ * <div class="feed">+ * <div class="tweet">Hello!</div>+ * <div class="tweet">Hi!</div>+ * </div>+ * ```+ *+ * ```js+ * const feedHandle = await page.$('.feed');+ * expect(await feedHandle.$$eval('.tweet', nodes =>+ * nodes.map(n => n.innerText))).toEqual(['Hello!', 'Hi!'],+ * );+ * ```+ *+ * @param selector A selector to query for.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-eval-on-selector-all-option-expression).+ */+ $$eval<R, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E[], void, R>, arg?: any): Promise<R>;++ /**+ * **NOTE** Use web assertions that assert visibility or a locator-based+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for) instead.+ *+ * Returns element specified by selector when it satisfies+ * [`state`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-state)+ * option. Returns `null` if waiting for `hidden` or `detached`.+ *+ * Wait for the+ * [`selector`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-selector)+ * relative to the element handle to satisfy+ * [`state`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-state) option+ * (either appear/disappear from dom, or become visible/hidden). If at the moment of calling the method+ * [`selector`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-selector)+ * already satisfies the condition, the method will return immediately. If the selector doesn't satisfy the condition+ * for the+ * [`timeout`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-timeout)+ * milliseconds, the function will throw.+ *+ * **Usage**+ *+ * ```js+ * await page.setContent(`<div><span></span></div>`);+ * const div = await page.$('div');+ * // Waiting for the 'span' selector relative to the div.+ * const span = await div.waitForSelector('span', { state: 'attached' });+ * ```+ *+ * **NOTE** This method does not work across navigations, use+ * [page.waitForSelector(selector[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-selector)+ * instead.+ *+ * @param selector A selector to query for.+ * @param options+ */+ waitForSelector<K extends keyof HTMLElementTagNameMap>(selector: K, options?: ElementHandleWaitForSelectorOptionsNotHidden): Promise<ElementHandleForTag<K>>;+ /**+ * **NOTE** Use web assertions that assert visibility or a locator-based+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for) instead.+ *+ * Returns element specified by selector when it satisfies+ * [`state`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-state)+ * option. Returns `null` if waiting for `hidden` or `detached`.+ *+ * Wait for the+ * [`selector`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-selector)+ * relative to the element handle to satisfy+ * [`state`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-state) option+ * (either appear/disappear from dom, or become visible/hidden). If at the moment of calling the method+ * [`selector`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-selector)+ * already satisfies the condition, the method will return immediately. If the selector doesn't satisfy the condition+ * for the+ * [`timeout`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-timeout)+ * milliseconds, the function will throw.+ *+ * **Usage**+ *+ * ```js+ * await page.setContent(`<div><span></span></div>`);+ * const div = await page.$('div');+ * // Waiting for the 'span' selector relative to the div.+ * const span = await div.waitForSelector('span', { state: 'attached' });+ * ```+ *+ * **NOTE** This method does not work across navigations, use+ * [page.waitForSelector(selector[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-selector)+ * instead.+ *+ * @param selector A selector to query for.+ * @param options+ */+ waitForSelector(selector: string, options?: ElementHandleWaitForSelectorOptionsNotHidden): Promise<ElementHandle<SVGElement | HTMLElement>>;+ /**+ * **NOTE** Use web assertions that assert visibility or a locator-based+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for) instead.+ *+ * Returns element specified by selector when it satisfies+ * [`state`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-state)+ * option. Returns `null` if waiting for `hidden` or `detached`.+ *+ * Wait for the+ * [`selector`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-selector)+ * relative to the element handle to satisfy+ * [`state`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-state) option+ * (either appear/disappear from dom, or become visible/hidden). If at the moment of calling the method+ * [`selector`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-selector)+ * already satisfies the condition, the method will return immediately. If the selector doesn't satisfy the condition+ * for the+ * [`timeout`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-timeout)+ * milliseconds, the function will throw.+ *+ * **Usage**+ *+ * ```js+ * await page.setContent(`<div><span></span></div>`);+ * const div = await page.$('div');+ * // Waiting for the 'span' selector relative to the div.+ * const span = await div.waitForSelector('span', { state: 'attached' });+ * ```+ *+ * **NOTE** This method does not work across navigations, use+ * [page.waitForSelector(selector[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-selector)+ * instead.+ *+ * @param selector A selector to query for.+ * @param options+ */+ waitForSelector<K extends keyof HTMLElementTagNameMap>(selector: K, options: ElementHandleWaitForSelectorOptions): Promise<ElementHandleForTag<K> | null>;+ /**+ * **NOTE** Use web assertions that assert visibility or a locator-based+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for) instead.+ *+ * Returns element specified by selector when it satisfies+ * [`state`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-state)+ * option. Returns `null` if waiting for `hidden` or `detached`.+ *+ * Wait for the+ * [`selector`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-selector)+ * relative to the element handle to satisfy+ * [`state`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-state) option+ * (either appear/disappear from dom, or become visible/hidden). If at the moment of calling the method+ * [`selector`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-selector)+ * already satisfies the condition, the method will return immediately. If the selector doesn't satisfy the condition+ * for the+ * [`timeout`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-selector-option-timeout)+ * milliseconds, the function will throw.+ *+ * **Usage**+ *+ * ```js+ * await page.setContent(`<div><span></span></div>`);+ * const div = await page.$('div');+ * // Waiting for the 'span' selector relative to the div.+ * const span = await div.waitForSelector('span', { state: 'attached' });+ * ```+ *+ * **NOTE** This method does not work across navigations, use+ * [page.waitForSelector(selector[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-selector)+ * instead.+ *+ * @param selector A selector to query for.+ * @param options+ */+ waitForSelector(selector: string, options: ElementHandleWaitForSelectorOptions): Promise<null|ElementHandle<SVGElement | HTMLElement>>;+ /**+ * This method returns the bounding box of the element, or `null` if the element is not visible. The bounding box is+ * calculated relative to the main frame viewport - which is usually the same as the browser window.+ *+ * Scrolling affects the returned bounding box, similarly to+ * [Element.getBoundingClientRect](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).+ * That means `x` and/or `y` may be negative.+ *+ * Elements from child frames return the bounding box relative to the main frame, unlike the+ * [Element.getBoundingClientRect](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).+ *+ * Assuming the page is static, it is safe to use bounding box coordinates to perform input. For example, the+ * following snippet should click the center of the element.+ *+ * **Usage**+ *+ * ```js+ * const box = await elementHandle.boundingBox();+ * await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);+ * ```+ *+ */+ boundingBox(): Promise<null|{+ /**+ * the x coordinate of the element in pixels.+ */+ x: number;++ /**+ * the y coordinate of the element in pixels.+ */+ y: number;++ /**+ * the width of the element in pixels.+ */+ width: number;++ /**+ * the height of the element in pixels.+ */+ height: number;+ }>;++ /**+ * **NOTE** Use locator-based [locator.check([options])](https://playwright.dev/docs/api/class-locator#locator-check) instead.+ * Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method checks the element by performing the following steps:+ * 1. Ensure that element is a checkbox or a radio input. If not, this method throws. If the element is already+ * checked, this method returns immediately.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the element, unless+ * [`force`](https://playwright.dev/docs/api/class-elementhandle#element-handle-check-option-force) option is+ * set.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element.+ * 1. Ensure that the element is now checked. If not, this method throws.+ *+ * If the element is detached from the DOM at any moment during the action, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-elementhandle#element-handle-check-option-timeout), this method+ * throws a [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param options+ */+ check(options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.click([options])](https://playwright.dev/docs/api/class-locator#locator-click) instead.+ * Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method clicks the element by performing the following steps:+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the element, unless+ * [`force`](https://playwright.dev/docs/api/class-elementhandle#element-handle-click-option-force) option is+ * set.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-elementhandle#element-handle-click-option-position).+ * 1. Wait for initiated navigations to either succeed or fail, unless+ * [`noWaitAfter`](https://playwright.dev/docs/api/class-elementhandle#element-handle-click-option-no-wait-after)+ * option is set.+ *+ * If the element is detached from the DOM at any moment during the action, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-elementhandle#element-handle-click-option-timeout), this method+ * throws a [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param options+ */+ click(options?: {+ /**+ * Defaults to `left`.+ */+ button?: "left"|"right"|"middle";++ /**+ * defaults to 1. See [UIEvent.detail].+ */+ clickCount?: number;++ /**+ * Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You+ * can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as+ * navigating to inaccessible pages. Defaults to `false`.+ * @deprecated This option will default to `true` in the future.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * Returns the content frame for element handles referencing iframe nodes, or `null` otherwise+ */+ contentFrame(): Promise<null|Frame>;++ /**+ * **NOTE** Use locator-based [locator.dblclick([options])](https://playwright.dev/docs/api/class-locator#locator-dblclick)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method double clicks the element by performing the following steps:+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the element, unless+ * [`force`](https://playwright.dev/docs/api/class-elementhandle#element-handle-dblclick-option-force) option is+ * set.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to double click in the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-elementhandle#element-handle-dblclick-option-position).+ *+ * If the element is detached from the DOM at any moment during the action, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-elementhandle#element-handle-dblclick-option-timeout), this+ * method throws a [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables+ * this.+ *+ * **NOTE** `elementHandle.dblclick()` dispatches two `click` events and a single `dblclick` event.+ *+ * @param options+ */+ dblclick(options?: {+ /**+ * Defaults to `left`.+ */+ button?: "left"|"right"|"middle";++ /**+ * Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based+ * [locator.dispatchEvent(type[, eventInit, options])](https://playwright.dev/docs/api/class-locator#locator-dispatch-event)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the element,+ * `click` is dispatched. This is equivalent to calling+ * [element.click()](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click).+ *+ * **Usage**+ *+ * ```js+ * await elementHandle.dispatchEvent('click');+ * ```+ *+ * Under the hood, it creates an instance of an event based on the given+ * [`type`](https://playwright.dev/docs/api/class-elementhandle#element-handle-dispatch-event-option-type),+ * initializes it with+ * [`eventInit`](https://playwright.dev/docs/api/class-elementhandle#element-handle-dispatch-event-option-event-init)+ * properties and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.+ *+ * Since+ * [`eventInit`](https://playwright.dev/docs/api/class-elementhandle#element-handle-dispatch-event-option-event-init)+ * is event-specific, please refer to the events documentation for the lists of initial properties:+ * - [DeviceMotionEvent](https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent/DeviceMotionEvent)+ * - [DeviceOrientationEvent](https://developer.mozilla.org/en-US/docs/Web/API/DeviceOrientationEvent/DeviceOrientationEvent)+ * - [DragEvent](https://developer.mozilla.org/en-US/docs/Web/API/DragEvent/DragEvent)+ * - [Event](https://developer.mozilla.org/en-US/docs/Web/API/Event/Event)+ * - [FocusEvent](https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent/FocusEvent)+ * - [KeyboardEvent](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/KeyboardEvent)+ * - [MouseEvent](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/MouseEvent)+ * - [PointerEvent](https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/PointerEvent)+ * - [TouchEvent](https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent/TouchEvent)+ * - [WheelEvent](https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/WheelEvent)+ *+ * You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:+ *+ * ```js+ * // Note you can only create DataTransfer in Chromium and Firefox+ * const dataTransfer = await page.evaluateHandle(() => new DataTransfer());+ * await elementHandle.dispatchEvent('dragstart', { dataTransfer });+ * ```+ *+ * @param type DOM event type: `"click"`, `"dragstart"`, etc.+ * @param eventInit Optional event-specific initialization properties.+ */+ dispatchEvent(type: string, eventInit?: EvaluationArgument): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.fill(value[, options])](https://playwright.dev/docs/api/class-locator#locator-fill)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method waits for [actionability](https://playwright.dev/docs/actionability) checks, focuses the element, fills it and triggers an+ * `input` event after filling. Note that you can pass an empty string to clear the input field.+ *+ * If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an+ * error. However, if the element is inside the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled+ * instead.+ *+ * To send fine-grained keyboard events, use+ * [locator.pressSequentially(text[, options])](https://playwright.dev/docs/api/class-locator#locator-press-sequentially).+ * @param value Value to set for the `<input>`, `<textarea>` or `[contenteditable]` element.+ * @param options+ */+ fill(value: string, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.focus([options])](https://playwright.dev/docs/api/class-locator#locator-focus) instead.+ * Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Calls [focus](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) on the element.+ */+ focus(): Promise<void>;++ /**+ * **NOTE** Use locator-based+ * [locator.getAttribute(name[, options])](https://playwright.dev/docs/api/class-locator#locator-get-attribute)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns element attribute value.+ * @param name Attribute name to get the value for.+ */+ getAttribute(name: string): Promise<null|string>;++ /**+ * **NOTE** Use locator-based [locator.hover([options])](https://playwright.dev/docs/api/class-locator#locator-hover) instead.+ * Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method hovers over the element by performing the following steps:+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the element, unless+ * [`force`](https://playwright.dev/docs/api/class-elementhandle#element-handle-hover-option-force) option is+ * set.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to hover over the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-elementhandle#element-handle-hover-option-position).+ *+ * If the element is detached from the DOM at any moment during the action, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-elementhandle#element-handle-hover-option-timeout), this method+ * throws a [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param options+ */+ hover(options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.innerHTML([options])](https://playwright.dev/docs/api/class-locator#locator-inner-html)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns the `element.innerHTML`.+ */+ innerHTML(): Promise<string>;++ /**+ * **NOTE** Use locator-based [locator.innerText([options])](https://playwright.dev/docs/api/class-locator#locator-inner-text)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns the `element.innerText`.+ */+ innerText(): Promise<string>;++ /**+ * **NOTE** Use locator-based+ * [locator.inputValue([options])](https://playwright.dev/docs/api/class-locator#locator-input-value) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns `input.value` for the selected `<input>` or `<textarea>` or `<select>` element.+ *+ * Throws for non-input elements. However, if the element is inside the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), returns the value of the+ * control.+ * @param options+ */+ inputValue(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<string>;++ /**+ * **NOTE** Use locator-based [locator.isChecked([options])](https://playwright.dev/docs/api/class-locator#locator-is-checked)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is checked. Throws if the element is not a checkbox or radio input.+ */+ isChecked(): Promise<boolean>;++ /**+ * **NOTE** Use locator-based+ * [locator.isDisabled([options])](https://playwright.dev/docs/api/class-locator#locator-is-disabled) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/docs/actionability#enabled).+ */+ isDisabled(): Promise<boolean>;++ /**+ * **NOTE** Use locator-based+ * [locator.isEditable([options])](https://playwright.dev/docs/api/class-locator#locator-is-editable) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is [editable](https://playwright.dev/docs/actionability#editable).+ */+ isEditable(): Promise<boolean>;++ /**+ * **NOTE** Use locator-based [locator.isEnabled([options])](https://playwright.dev/docs/api/class-locator#locator-is-enabled)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is [enabled](https://playwright.dev/docs/actionability#enabled).+ */+ isEnabled(): Promise<boolean>;++ /**+ * **NOTE** Use locator-based [locator.isHidden([options])](https://playwright.dev/docs/api/class-locator#locator-is-hidden)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/docs/actionability#visible).+ */+ isHidden(): Promise<boolean>;++ /**+ * **NOTE** Use locator-based [locator.isVisible([options])](https://playwright.dev/docs/api/class-locator#locator-is-visible)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns whether the element is [visible](https://playwright.dev/docs/actionability#visible).+ */+ isVisible(): Promise<boolean>;++ /**+ * Returns the frame containing the given element.+ */+ ownerFrame(): Promise<null|Frame>;++ /**+ * **NOTE** Use locator-based [locator.press(key[, options])](https://playwright.dev/docs/api/class-locator#locator-press)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Focuses the element, and then uses+ * [keyboard.down(key)](https://playwright.dev/docs/api/class-keyboard#keyboard-down) and+ * [keyboard.up(key)](https://playwright.dev/docs/api/class-keyboard#keyboard-up).+ *+ * [`key`](https://playwright.dev/docs/api/class-elementhandle#element-handle-press-option-key) can specify the+ * intended [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) value or a single+ * character to generate the text for. A superset of the+ * [`key`](https://playwright.dev/docs/api/class-elementhandle#element-handle-press-option-key) values can be found+ * [here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:+ *+ * `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`,+ * `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,+ * etc.+ *+ * Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,+ * `ControlOrMeta`.+ *+ * Holding down `Shift` will type the text that corresponds to the+ * [`key`](https://playwright.dev/docs/api/class-elementhandle#element-handle-press-option-key) in the upper case.+ *+ * If [`key`](https://playwright.dev/docs/api/class-elementhandle#element-handle-press-option-key) is a single+ * character, it is case-sensitive, so the values `a` and `A` will generate different respective texts.+ *+ * Shortcuts such as `key: "Control+o"`, `key: "Control++` or `key: "Control+Shift+T"` are supported as well. When+ * specified with the modifier, modifier is pressed and being held while the subsequent key is being pressed.+ * @param key Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.+ * @param options+ */+ press(key: string, options?: {+ /**+ * Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You+ * can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as+ * navigating to inaccessible pages. Defaults to `false`.+ * @deprecated This option will default to `true` in the future.+ */+ noWaitAfter?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.screenshot([options])](https://playwright.dev/docs/api/class-locator#locator-screenshot)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method captures a screenshot of the page, clipped to the size and position of this particular element. If the+ * element is covered by other elements, it will not be actually visible on the screenshot. If the element is a+ * scrollable container, only the currently scrolled content will be visible on the screenshot.+ *+ * This method waits for the [actionability](https://playwright.dev/docs/actionability) checks, then scrolls element into view before taking+ * a screenshot. If the element is detached from DOM, the method throws an error.+ *+ * Returns the buffer with the captured screenshot.+ * @param options+ */+ screenshot(options?: {+ /**+ * When set to `"disabled"`, stops CSS animations, CSS transitions and Web Animations. Animations get different+ * treatment depending on their duration:+ * - finite animations are fast-forwarded to completion, so they'll fire `transitionend` event.+ * - infinite animations are canceled to initial state, and then played over after the screenshot.+ *+ * Defaults to `"allow"` that leaves animations untouched.+ */+ animations?: "disabled"|"allow";++ /**+ * When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be+ * changed. Defaults to `"hide"`.+ */+ caret?: "hide"|"initial";++ /**+ * Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink+ * box `#FF00FF` (customized by+ * [`maskColor`](https://playwright.dev/docs/api/class-elementhandle#element-handle-screenshot-option-mask-color))+ * that completely covers its bounding box.+ */+ mask?: Array<Locator>;++ /**+ * Specify the color of the overlay box for masked elements, in+ * [CSS color format](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value). Default color is pink `#FF00FF`.+ */+ maskColor?: string;++ /**+ * Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images.+ * Defaults to `false`.+ */+ omitBackground?: boolean;++ /**+ * The file path to save the image to. The screenshot type will be inferred from file extension. If+ * [`path`](https://playwright.dev/docs/api/class-elementhandle#element-handle-screenshot-option-path) is a relative+ * path, then it is resolved relative to the current working directory. If no path is provided, the image won't be+ * saved to the disk.+ */+ path?: string;++ /**+ * The quality of the image, between 0-100. Not applicable to `png` images.+ */+ quality?: number;++ /**+ * When set to `"css"`, screenshot will have a single pixel per each css pixel on the page. For high-dpi devices, this+ * will keep screenshots small. Using `"device"` option will produce a single pixel per each device pixel, so+ * screenshots of high-dpi devices will be twice as large or even larger.+ *+ * Defaults to `"device"`.+ */+ scale?: "css"|"device";++ /**+ * Text of the stylesheet to apply while making the screenshot. This is where you can hide dynamic elements, make+ * elements invisible or change their properties to help you creating repeatable screenshots. This stylesheet pierces+ * the Shadow DOM and applies to the inner frames.+ */+ style?: string;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * Specify screenshot type, defaults to `png`.+ */+ type?: "png"|"jpeg";+ }): Promise<Buffer>;++ /**+ * **NOTE** Use locator-based+ * [locator.scrollIntoViewIfNeeded([options])](https://playwright.dev/docs/api/class-locator#locator-scroll-into-view-if-needed)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method waits for [actionability](https://playwright.dev/docs/actionability) checks, then tries to scroll element into view, unless+ * it is completely visible as defined by+ * [IntersectionObserver](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)'s `ratio`.+ *+ * Throws when `elementHandle` does not point to an element+ * [connected](https://developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.+ *+ * See [scrolling](https://playwright.dev/docs/input#scrolling) for alternative ways to scroll.+ * @param options+ */+ scrollIntoViewIfNeeded(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based+ * [locator.selectOption(values[, options])](https://playwright.dev/docs/api/class-locator#locator-select-option)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method waits for [actionability](https://playwright.dev/docs/actionability) checks, waits until all specified options are present in+ * the `<select>` element and selects these options.+ *+ * If the target element is not a `<select>` element, this method throws an error. However, if the element is inside+ * the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be used+ * instead.+ *+ * Returns the array of option values that have been successfully selected.+ *+ * Triggers a `change` and `input` event once all the provided options have been selected.+ *+ * **Usage**+ *+ * ```js+ * // Single selection matching the value or label+ * handle.selectOption('blue');+ *+ * // single selection matching the label+ * handle.selectOption({ label: 'Blue' });+ *+ * // multiple selection+ * handle.selectOption(['red', 'green', 'blue']);+ * ```+ *+ * @param values Options to select. If the `<select>` has the `multiple` attribute, all matching options are selected, otherwise+ * only the first option matching one of the passed options is selected. String values are matching both values and+ * labels. Option is considered matching if all specified properties match.+ * @param options+ */+ selectOption(values: null|string|ElementHandle|ReadonlyArray<string>|{+ /**+ * Matches by `option.value`. Optional.+ */+ value?: string;++ /**+ * Matches by `option.label`. Optional.+ */+ label?: string;++ /**+ * Matches by the index. Optional.+ */+ index?: number;+ }|ReadonlyArray<ElementHandle>|ReadonlyArray<{+ /**+ * Matches by `option.value`. Optional.+ */+ value?: string;++ /**+ * Matches by `option.label`. Optional.+ */+ label?: string;++ /**+ * Matches by the index. Optional.+ */+ index?: number;+ }>, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<Array<string>>;++ /**+ * **NOTE** Use locator-based+ * [locator.selectText([options])](https://playwright.dev/docs/api/class-locator#locator-select-text) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * This method waits for [actionability](https://playwright.dev/docs/actionability) checks, then focuses the element and selects all its+ * text content.+ *+ * If the element is inside the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), focuses and selects text in+ * the control instead.+ * @param options+ */+ selectText(options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based+ * [locator.setChecked(checked[, options])](https://playwright.dev/docs/api/class-locator#locator-set-checked)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method checks or unchecks an element by performing the following steps:+ * 1. Ensure that element is a checkbox or a radio input. If not, this method throws.+ * 1. If the element already has the right checked state, this method returns immediately.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-elementhandle#element-handle-set-checked-option-force) option+ * is set. If the element is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element.+ * 1. Ensure that the element is now checked or unchecked. If not, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-elementhandle#element-handle-set-checked-option-timeout), this+ * method throws a [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables+ * this.+ * @param checked Whether to check or uncheck the checkbox.+ * @param options+ */+ setChecked(checked: boolean, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based+ * [locator.setInputFiles(files[, options])](https://playwright.dev/docs/api/class-locator#locator-set-input-files)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * Sets the value of the file input to these file paths or files. If some of the `filePaths` are relative paths, then+ * they are resolved relative to the current working directory. For empty array, clears the selected files. For inputs+ * with a `[webkitdirectory]` attribute, only a single directory path is supported.+ *+ * This method expects [ElementHandle](https://playwright.dev/docs/api/class-elementhandle) to point to an+ * [input element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input). However, if the element is inside+ * the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), targets the control instead.+ * @param files+ * @param options+ */+ setInputFiles(files: string|ReadonlyArray<string>|{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }|ReadonlyArray<{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }>, options?: {+ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.tap([options])](https://playwright.dev/docs/api/class-locator#locator-tap) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * This method taps the element by performing the following steps:+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the element, unless+ * [`force`](https://playwright.dev/docs/api/class-elementhandle#element-handle-tap-option-force) option is set.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.touchscreen](https://playwright.dev/docs/api/class-page#page-touchscreen) to tap the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-elementhandle#element-handle-tap-option-position).+ *+ * If the element is detached from the DOM at any moment during the action, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-elementhandle#element-handle-tap-option-timeout), this method+ * throws a [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ *+ * **NOTE** `elementHandle.tap()` requires that the `hasTouch` option of the browser context be set to true.+ *+ * @param options+ */+ tap(options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based+ * [locator.textContent([options])](https://playwright.dev/docs/api/class-locator#locator-text-content) instead. Read+ * more about [locators](https://playwright.dev/docs/locators).+ *+ * Returns the `node.textContent`.+ */+ textContent(): Promise<null|string>;++ /**+ * Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the+ * text.+ *+ * To press a special key, like `Control` or `ArrowDown`, use+ * [elementHandle.press(key[, options])](https://playwright.dev/docs/api/class-elementhandle#element-handle-press).+ *+ * **Usage**+ * @deprecated In most cases, you should use+ * [locator.fill(value[, options])](https://playwright.dev/docs/api/class-locator#locator-fill) instead. You only need+ * to press keys one by one if there is special keyboard handling on the page - in this case use+ * [locator.pressSequentially(text[, options])](https://playwright.dev/docs/api/class-locator#locator-press-sequentially).+ * @param text A text to type into a focused element.+ * @param options+ */+ type(text: string, options?: {+ /**+ * Time to wait between key presses in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * **NOTE** Use locator-based [locator.uncheck([options])](https://playwright.dev/docs/api/class-locator#locator-uncheck)+ * instead. Read more about [locators](https://playwright.dev/docs/locators).+ *+ * This method checks the element by performing the following steps:+ * 1. Ensure that element is a checkbox or a radio input. If not, this method throws. If the element is already+ * unchecked, this method returns immediately.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the element, unless+ * [`force`](https://playwright.dev/docs/api/class-elementhandle#element-handle-uncheck-option-force) option is+ * set.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element.+ * 1. Ensure that the element is now unchecked. If not, this method throws.+ *+ * If the element is detached from the DOM at any moment during the action, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-elementhandle#element-handle-uncheck-option-timeout), this method+ * throws a [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param options+ */+ uncheck(options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * Returns when the element satisfies the+ * [`state`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-element-state-option-state).+ *+ * Depending on the+ * [`state`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-element-state-option-state)+ * parameter, this method waits for one of the [actionability](https://playwright.dev/docs/actionability) checks to pass. This method throws+ * when the element is detached while waiting, unless waiting for the `"hidden"` state.+ * - `"visible"` Wait until the element is [visible](https://playwright.dev/docs/actionability#visible).+ * - `"hidden"` Wait until the element is [not visible](https://playwright.dev/docs/actionability#visible) or not attached. Note that+ * waiting for hidden does not throw when the element detaches.+ * - `"stable"` Wait until the element is both [visible](https://playwright.dev/docs/actionability#visible) and+ * [stable](https://playwright.dev/docs/actionability#stable).+ * - `"enabled"` Wait until the element is [enabled](https://playwright.dev/docs/actionability#enabled).+ * - `"disabled"` Wait until the element is [not enabled](https://playwright.dev/docs/actionability#enabled).+ * - `"editable"` Wait until the element is [editable](https://playwright.dev/docs/actionability#editable).+ *+ * If the element does not satisfy the condition for the+ * [`timeout`](https://playwright.dev/docs/api/class-elementhandle#element-handle-wait-for-element-state-option-timeout)+ * milliseconds, this method will throw.+ * @param state A state to wait for, see below for more details.+ * @param options+ */+ waitForElementState(state: "visible"|"hidden"|"stable"|"enabled"|"disabled"|"editable", options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;+}++/**+ * Locators are the central piece of Playwright's auto-waiting and retry-ability. In a nutshell, locators represent a+ * way to find element(s) on the page at any moment. A locator can be created with the+ * [page.locator(selector[, options])](https://playwright.dev/docs/api/class-page#page-locator) method.+ *+ * [Learn more about locators](https://playwright.dev/docs/locators).+ */+export interface Locator {+ /**+ * Execute JavaScript code in the page, taking the matching element as an argument.+ *+ * **Details**+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-option-expression), called with the+ * matching element as a first argument, and+ * [`arg`](https://playwright.dev/docs/api/class-locator#locator-evaluate-option-arg) as a second argument.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-option-expression) returns a+ * [Promise], this method will wait for the promise to resolve and return its value.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-option-expression) throws or+ * rejects, this method throws.+ *+ * **Usage**+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-option-expression).+ * @param options+ */+ evaluate<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, R>, arg: Arg, options?: {+ timeout?: number;+ }): Promise<R>;+ /**+ * Execute JavaScript code in the page, taking the matching element as an argument.+ *+ * **Details**+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-option-expression), called with the+ * matching element as a first argument, and+ * [`arg`](https://playwright.dev/docs/api/class-locator#locator-evaluate-option-arg) as a second argument.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-option-expression) returns a+ * [Promise], this method will wait for the promise to resolve and return its value.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-option-expression) throws or+ * rejects, this method throws.+ *+ * **Usage**+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-option-expression).+ * @param options+ */+ evaluate<R, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, void, R>, options?: {+ timeout?: number;+ }): Promise<R>;+ /**+ * Execute JavaScript code in the page, taking the matching element as an argument, and return a+ * [JSHandle](https://playwright.dev/docs/api/class-jshandle) with the result.+ *+ * **Details**+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle-option-expression) as+ * a[JSHandle](https://playwright.dev/docs/api/class-jshandle), called with the matching element as a first argument,+ * and [`arg`](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle-option-arg) as a second argument.+ *+ * The only difference between+ * [locator.evaluate(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate)+ * and+ * [locator.evaluateHandle(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle)+ * is that+ * [locator.evaluateHandle(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle)+ * returns [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle-option-expression)+ * returns a [Promise], this method will wait for the promise to resolve and return its value.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle-option-expression) throws+ * or rejects, this method throws.+ *+ * See [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle) for+ * more details.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle-option-expression).+ * @param options+ */+ evaluateHandle<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, R>, arg: Arg): Promise<SmartHandle<R>>;+ /**+ * Execute JavaScript code in the page, taking the matching element as an argument, and return a+ * [JSHandle](https://playwright.dev/docs/api/class-jshandle) with the result.+ *+ * **Details**+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle-option-expression) as+ * a[JSHandle](https://playwright.dev/docs/api/class-jshandle), called with the matching element as a first argument,+ * and [`arg`](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle-option-arg) as a second argument.+ *+ * The only difference between+ * [locator.evaluate(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate)+ * and+ * [locator.evaluateHandle(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle)+ * is that+ * [locator.evaluateHandle(pageFunction[, arg, options])](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle)+ * returns [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle-option-expression)+ * returns a [Promise], this method will wait for the promise to resolve and return its value.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle-option-expression) throws+ * or rejects, this method throws.+ *+ * See [page.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-page#page-evaluate-handle) for+ * more details.+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle-option-expression).+ * @param options+ */+ evaluateHandle<R, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, void, R>): Promise<SmartHandle<R>>;+ /**+ * Execute JavaScript code in the page, taking all matching elements as an argument.+ *+ * **Details**+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-all-option-expression), called with+ * an array of all matching elements as a first argument, and+ * [`arg`](https://playwright.dev/docs/api/class-locator#locator-evaluate-all-option-arg) as a second argument.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-all-option-expression) returns a+ * [Promise], this method will wait for the promise to resolve and return its value.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-all-option-expression) throws or+ * rejects, this method throws.+ *+ * **Usage**+ *+ * ```js+ * const locator = page.locator('div');+ * const moreThanTen = await locator.evaluateAll((divs, min) => divs.length > min, 10);+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-all-option-expression).+ */+ evaluateAll<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E[], Arg, R>, arg: Arg): Promise<R>;+ /**+ * Execute JavaScript code in the page, taking all matching elements as an argument.+ *+ * **Details**+ *+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-all-option-expression), called with+ * an array of all matching elements as a first argument, and+ * [`arg`](https://playwright.dev/docs/api/class-locator#locator-evaluate-all-option-arg) as a second argument.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-all-option-expression) returns a+ * [Promise], this method will wait for the promise to resolve and return its value.+ *+ * If [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-all-option-expression) throws or+ * rejects, this method throws.+ *+ * **Usage**+ *+ * ```js+ * const locator = page.locator('div');+ * const moreThanTen = await locator.evaluateAll((divs, min) => divs.length > min, 10);+ * ```+ *+ * @param pageFunction Function to be evaluated in the page context.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-all-option-expression).+ */+ evaluateAll<R, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E[], void, R>): Promise<R>;+ /**+ * **NOTE** Always prefer using [Locator](https://playwright.dev/docs/api/class-locator)s and web assertions over+ * [ElementHandle](https://playwright.dev/docs/api/class-elementhandle)s because latter are inherently racy.+ *+ * Resolves given locator to the first matching DOM element. If there are no matching elements, waits for one. If+ * multiple elements match the locator, throws.+ * @param options+ */+ elementHandle(options?: {+ timeout?: number;+ }): Promise<null|ElementHandle<SVGElement | HTMLElement>>;+ /**+ * When the locator points to a list of elements, this returns an array of locators, pointing to their respective+ * elements.+ *+ * **NOTE** [locator.all()](https://playwright.dev/docs/api/class-locator#locator-all) does not wait for elements to+ * match the locator, and instead immediately returns whatever is present in the page.+ *+ * When the list of elements changes dynamically,+ * [locator.all()](https://playwright.dev/docs/api/class-locator#locator-all) will produce unpredictable and flaky+ * results.+ *+ * When the list of elements is stable, but loaded dynamically, wait for the full list to finish loading before+ * calling [locator.all()](https://playwright.dev/docs/api/class-locator#locator-all).+ *+ * **Usage**+ *+ * ```js+ * for (const li of await page.getByRole('listitem').all())+ * await li.click();+ * ```+ *+ */+ all(): Promise<Array<Locator>>;++ /**+ * Returns an array of `node.innerText` values for all matching nodes.+ *+ * **NOTE** If you need to assert text on the page, prefer+ * [expect(locator).toHaveText(expected[, options])](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-have-text)+ * with+ * [`useInnerText`](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-have-text-option-use-inner-text)+ * option to avoid flakiness. See [assertions guide](https://playwright.dev/docs/test-assertions) for more details.+ *+ * **Usage**+ *+ * ```js+ * const texts = await page.getByRole('link').allInnerTexts();+ * ```+ *+ */+ allInnerTexts(): Promise<Array<string>>;++ /**+ * Returns an array of `node.textContent` values for all matching nodes.+ *+ * **NOTE** If you need to assert text on the page, prefer+ * [expect(locator).toHaveText(expected[, options])](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-have-text)+ * to avoid flakiness. See [assertions guide](https://playwright.dev/docs/test-assertions) for more details.+ *+ * **Usage**+ *+ * ```js+ * const texts = await page.getByRole('link').allTextContents();+ * ```+ *+ */+ allTextContents(): Promise<Array<string>>;++ /**+ * Creates a locator that matches both this locator and the argument locator.+ *+ * **Usage**+ *+ * The following example finds a button with a specific title.+ *+ * ```js+ * const button = page.getByRole('button').and(page.getByTitle('Subscribe'));+ * ```+ *+ * @param locator Additional locator to match.+ */+ and(locator: Locator): Locator;++ /**+ * Captures the aria snapshot of the given element. Read more about [aria snapshots](https://playwright.dev/docs/aria-snapshots) and+ * [expect(locator).toMatchAriaSnapshot(expected[, options])](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-match-aria-snapshot)+ * for the corresponding assertion.+ *+ * **Usage**+ *+ * ```js+ * await page.getByRole('link').ariaSnapshot();+ * ```+ *+ * **Details**+ *+ * This method captures the aria snapshot of the given element. The snapshot is a string that represents the state of+ * the element and its children. The snapshot can be used to assert the state of the element in the test, or to+ * compare it to state in the future.+ *+ * The ARIA snapshot is represented using [YAML](https://yaml.org/spec/1.2.2/) markup language:+ * - The keys of the objects are the roles and optional accessible names of the elements.+ * - The values are either text content or an array of child elements.+ * - Generic static text can be represented with the `text` key.+ *+ * Below is the HTML markup and the respective ARIA snapshot:+ *+ * ```html+ * <ul aria-label="Links">+ * <li><a href="/">Home</a></li>+ * <li><a href="/about">About</a></li>+ * <ul>+ * ```+ *+ * ```yml+ * - list "Links":+ * - listitem:+ * - link "Home"+ * - listitem:+ * - link "About"+ * ```+ *+ * @param options+ */+ ariaSnapshot(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<string>;++ /**+ * Calls [blur](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/blur) on the element.+ * @param options+ */+ blur(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * This method returns the bounding box of the element matching the locator, or `null` if the element is not visible.+ * The bounding box is calculated relative to the main frame viewport - which is usually the same as the browser+ * window.+ *+ * **Details**+ *+ * Scrolling affects the returned bounding box, similarly to+ * [Element.getBoundingClientRect](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).+ * That means `x` and/or `y` may be negative.+ *+ * Elements from child frames return the bounding box relative to the main frame, unlike the+ * [Element.getBoundingClientRect](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).+ *+ * Assuming the page is static, it is safe to use bounding box coordinates to perform input. For example, the+ * following snippet should click the center of the element.+ *+ * **Usage**+ *+ * ```js+ * const box = await page.getByRole('button').boundingBox();+ * await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);+ * ```+ *+ * @param options+ */+ boundingBox(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<null|{+ /**+ * the x coordinate of the element in pixels.+ */+ x: number;++ /**+ * the y coordinate of the element in pixels.+ */+ y: number;++ /**+ * the width of the element in pixels.+ */+ width: number;++ /**+ * the height of the element in pixels.+ */+ height: number;+ }>;++ /**+ * Ensure that checkbox or radio element is checked.+ *+ * **Details**+ *+ * Performs the following steps:+ * 1. Ensure that element is a checkbox or a radio input. If not, this method throws. If the element is already+ * checked, this method returns immediately.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the element, unless+ * [`force`](https://playwright.dev/docs/api/class-locator#locator-check-option-force) option is set.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element.+ * 1. Ensure that the element is now checked. If not, this method throws.+ *+ * If the element is detached from the DOM at any moment during the action, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-locator#locator-check-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ *+ * **Usage**+ *+ * ```js+ * await page.getByRole('checkbox').check();+ * ```+ *+ * @param options+ */+ check(options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * Clear the input field.+ *+ * **Details**+ *+ * This method waits for [actionability](https://playwright.dev/docs/actionability) checks, focuses the element, clears it and triggers an+ * `input` event after clearing.+ *+ * If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an+ * error. However, if the element is inside the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be cleared+ * instead.+ *+ * **Usage**+ *+ * ```js+ * await page.getByRole('textbox').clear();+ * ```+ *+ * @param options+ */+ clear(options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Click an element.+ *+ * **Details**+ *+ * This method clicks the element by performing the following steps:+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the element, unless+ * [`force`](https://playwright.dev/docs/api/class-locator#locator-click-option-force) option is set.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-locator#locator-click-option-position).+ * 1. Wait for initiated navigations to either succeed or fail, unless+ * [`noWaitAfter`](https://playwright.dev/docs/api/class-locator#locator-click-option-no-wait-after) option is+ * set.+ *+ * If the element is detached from the DOM at any moment during the action, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-locator#locator-click-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ *+ * **Usage**+ *+ * Click a button:+ *+ * ```js+ * await page.getByRole('button').click();+ * ```+ *+ * Shift-right-click at a specific position on a canvas:+ *+ * ```js+ * await page.locator('canvas').click({+ * button: 'right',+ * modifiers: ['Shift'],+ * position: { x: 23, y: 32 },+ * });+ * ```+ *+ * @param options+ */+ click(options?: {+ /**+ * Defaults to `left`.+ */+ button?: "left"|"right"|"middle";++ /**+ * defaults to 1. See [UIEvent.detail].+ */+ clickCount?: number;++ /**+ * Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You+ * can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as+ * navigating to inaccessible pages. Defaults to `false`.+ * @deprecated This option will default to `true` in the future.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard+ * `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys+ * are pressed.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * Returns a [FrameLocator](https://playwright.dev/docs/api/class-framelocator) object pointing to the same `iframe`+ * as this locator.+ *+ * Useful when you have a [Locator](https://playwright.dev/docs/api/class-locator) object obtained somewhere, and+ * later on would like to interact with the content inside the frame.+ *+ * For a reverse operation, use+ * [frameLocator.owner()](https://playwright.dev/docs/api/class-framelocator#frame-locator-owner).+ *+ * **Usage**+ *+ * ```js+ * const locator = page.locator('iframe[name="embedded"]');+ * // ...+ * const frameLocator = locator.contentFrame();+ * await frameLocator.getByRole('button').click();+ * ```+ *+ */+ contentFrame(): FrameLocator;++ /**+ * Returns the number of elements matching the locator.+ *+ * **NOTE** If you need to assert the number of elements on the page, prefer+ * [expect(locator).toHaveCount(count[, options])](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-have-count)+ * to avoid flakiness. See [assertions guide](https://playwright.dev/docs/test-assertions) for more details.+ *+ * **Usage**+ *+ * ```js+ * const count = await page.getByRole('listitem').count();+ * ```+ *+ */+ count(): Promise<number>;++ /**+ * Double-click an element.+ *+ * **Details**+ *+ * This method double clicks the element by performing the following steps:+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the element, unless+ * [`force`](https://playwright.dev/docs/api/class-locator#locator-dblclick-option-force) option is set.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to double click in the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-locator#locator-dblclick-option-position).+ *+ * If the element is detached from the DOM at any moment during the action, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-locator#locator-dblclick-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ *+ * **NOTE** `element.dblclick()` dispatches two `click` events and a single `dblclick` event.+ *+ * @param options+ */+ dblclick(options?: {+ /**+ * Defaults to `left`.+ */+ button?: "left"|"right"|"middle";++ /**+ * Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard+ * `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys+ * are pressed.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * Programmatically dispatch an event on the matching element.+ *+ * **Usage**+ *+ * ```js+ * await locator.dispatchEvent('click');+ * ```+ *+ * **Details**+ *+ * The snippet above dispatches the `click` event on the element. Regardless of the visibility state of the element,+ * `click` is dispatched. This is equivalent to calling+ * [element.click()](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click).+ *+ * Under the hood, it creates an instance of an event based on the given+ * [`type`](https://playwright.dev/docs/api/class-locator#locator-dispatch-event-option-type), initializes it with+ * [`eventInit`](https://playwright.dev/docs/api/class-locator#locator-dispatch-event-option-event-init) properties+ * and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.+ *+ * Since [`eventInit`](https://playwright.dev/docs/api/class-locator#locator-dispatch-event-option-event-init) is+ * event-specific, please refer to the events documentation for the lists of initial properties:+ * - [DeviceMotionEvent](https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent/DeviceMotionEvent)+ * - [DeviceOrientationEvent](https://developer.mozilla.org/en-US/docs/Web/API/DeviceOrientationEvent/DeviceOrientationEvent)+ * - [DragEvent](https://developer.mozilla.org/en-US/docs/Web/API/DragEvent/DragEvent)+ * - [Event](https://developer.mozilla.org/en-US/docs/Web/API/Event/Event)+ * - [FocusEvent](https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent/FocusEvent)+ * - [KeyboardEvent](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/KeyboardEvent)+ * - [MouseEvent](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/MouseEvent)+ * - [PointerEvent](https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/PointerEvent)+ * - [TouchEvent](https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent/TouchEvent)+ * - [WheelEvent](https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/WheelEvent)+ *+ * You can also specify [JSHandle](https://playwright.dev/docs/api/class-jshandle) as the property value if you want+ * live objects to be passed into the event:+ *+ * ```js+ * const dataTransfer = await page.evaluateHandle(() => new DataTransfer());+ * await locator.dispatchEvent('dragstart', { dataTransfer });+ * ```+ *+ * @param type DOM event type: `"click"`, `"dragstart"`, etc.+ * @param eventInit Optional event-specific initialization properties.+ * @param options+ */+ dispatchEvent(type: string, eventInit?: EvaluationArgument, options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Drag the source element towards the target element and drop it.+ *+ * **Details**+ *+ * This method drags the locator to another target locator or target position. It will first move to the source+ * element, perform a `mousedown`, then move to the target element or position and perform a `mouseup`.+ *+ * **Usage**+ *+ * ```js+ * const source = page.locator('#source');+ * const target = page.locator('#target');+ *+ * await source.dragTo(target);+ * // or specify exact positions relative to the top-left corners of the elements:+ * await source.dragTo(target, {+ * sourcePosition: { x: 34, y: 7 },+ * targetPosition: { x: 10, y: 20 },+ * });+ * ```+ *+ * @param target Locator of the element to drag to.+ * @param options+ */+ dragTo(target: Locator, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * Clicks on the source element at this point relative to the top-left corner of the element's padding box. If not+ * specified, some visible point of the element is used.+ */+ sourcePosition?: {+ x: number;++ y: number;+ };++ /**+ * Drops on the target element at this point relative to the top-left corner of the element's padding box. If not+ * specified, some visible point of the element is used.+ */+ targetPosition?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * **NOTE** Always prefer using [Locator](https://playwright.dev/docs/api/class-locator)s and web assertions over+ * [ElementHandle](https://playwright.dev/docs/api/class-elementhandle)s because latter are inherently racy.+ *+ * Resolves given locator to all matching DOM elements. If there are no matching elements, returns an empty list.+ */+ elementHandles(): Promise<Array<ElementHandle>>;++ /**+ * Set a value to the input field.+ *+ * **Usage**+ *+ * ```js+ * await page.getByRole('textbox').fill('example value');+ * ```+ *+ * **Details**+ *+ * This method waits for [actionability](https://playwright.dev/docs/actionability) checks, focuses the element, fills it and triggers an+ * `input` event after filling. Note that you can pass an empty string to clear the input field.+ *+ * If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an+ * error. However, if the element is inside the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled+ * instead.+ *+ * To send fine-grained keyboard events, use+ * [locator.pressSequentially(text[, options])](https://playwright.dev/docs/api/class-locator#locator-press-sequentially).+ * @param value Value to set for the `<input>`, `<textarea>` or `[contenteditable]` element.+ * @param options+ */+ fill(value: string, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * This method narrows existing locator according to the options, for example filters by text. It can be chained to+ * filter multiple times.+ *+ * **Usage**+ *+ * ```js+ * const rowLocator = page.locator('tr');+ * // ...+ * await rowLocator+ * .filter({ hasText: 'text in column 1' })+ * .filter({ has: page.getByRole('button', { name: 'column 2 button' }) })+ * .screenshot();+ * ```+ *+ * @param options+ */+ filter(options?: {+ /**+ * Narrows down the results of the method to those which contain elements matching this relative locator. For example,+ * `article` that has `text=Playwright` matches `<article><div>Playwright</div></article>`.+ *+ * Inner locator **must be relative** to the outer locator and is queried starting with the outer locator match, not+ * the document root. For example, you can find `content` that has `div` in+ * `<article><content><div>Playwright</div></content></article>`. However, looking for `content` that has `article+ * div` will fail, because the inner locator must be relative and should not use any elements outside the `content`.+ *+ * Note that outer and inner locators must belong to the same frame. Inner locator must not contain+ * [FrameLocator](https://playwright.dev/docs/api/class-framelocator)s.+ */+ has?: Locator;++ /**+ * Matches elements that do not contain an element that matches an inner locator. Inner locator is queried against the+ * outer one. For example, `article` that does not have `div` matches `<article><span>Playwright</span></article>`.+ *+ * Note that outer and inner locators must belong to the same frame. Inner locator must not contain+ * [FrameLocator](https://playwright.dev/docs/api/class-framelocator)s.+ */+ hasNot?: Locator;++ /**+ * Matches elements that do not contain specified text somewhere inside, possibly in a child or a descendant element.+ * When passed a [string], matching is case-insensitive and searches for a substring.+ */+ hasNotText?: string|RegExp;++ /**+ * Matches elements containing specified text somewhere inside, possibly in a child or a descendant element. When+ * passed a [string], matching is case-insensitive and searches for a substring. For example, `"Playwright"` matches+ * `<article><div>Playwright</div></article>`.+ */+ hasText?: string|RegExp;+ }): Locator;++ /**+ * Returns locator to the first matching element.+ */+ first(): Locator;++ /**+ * Calls [focus](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) on the matching element.+ * @param options+ */+ focus(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * When working with iframes, you can create a frame locator that will enter the iframe and allow locating elements in+ * that iframe:+ *+ * **Usage**+ *+ * ```js+ * const locator = page.frameLocator('iframe').getByText('Submit');+ * await locator.click();+ * ```+ *+ * @param selector A selector to use when resolving DOM element.+ */+ frameLocator(selector: string): FrameLocator;++ /**+ * Returns the matching element's attribute value.+ *+ * **NOTE** If you need to assert an element's attribute, prefer+ * [expect(locator).toHaveAttribute(name, value[, options])](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-have-attribute)+ * to avoid flakiness. See [assertions guide](https://playwright.dev/docs/test-assertions) for more details.+ *+ * @param name Attribute name to get the value for.+ * @param options+ */+ getAttribute(name: string, options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<null|string>;++ /**+ * Allows locating elements by their alt text.+ *+ * **Usage**+ *+ * For example, this method will find the image by alt text "Playwright logo":+ *+ * ```html+ * <img alt='Playwright logo'>+ * ```+ *+ * ```js+ * await page.getByAltText('Playwright logo').click();+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByAltText(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating input elements by the text of the associated `<label>` or `aria-labelledby` element, or by the+ * `aria-label` attribute.+ *+ * **Usage**+ *+ * For example, this method will find inputs by label "Username" and "Password" in the following DOM:+ *+ * ```html+ * <input aria-label="Username">+ * <label for="password-input">Password:</label>+ * <input id="password-input">+ * ```+ *+ * ```js+ * await page.getByLabel('Username').fill('john');+ * await page.getByLabel('Password').fill('secret');+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByLabel(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating input elements by the placeholder text.+ *+ * **Usage**+ *+ * For example, consider the following DOM structure.+ *+ * ```html+ * <input type="email" placeholder="[email protected]" />+ * ```+ *+ * You can fill the input after locating it by the placeholder text:+ *+ * ```js+ * await page+ * .getByPlaceholder('[email protected]')+ * .fill('[email protected]');+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByPlaceholder(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating elements by their [ARIA role](https://www.w3.org/TR/wai-aria-1.2/#roles),+ * [ARIA attributes](https://www.w3.org/TR/wai-aria-1.2/#aria-attributes) and+ * [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).+ *+ * **Usage**+ *+ * Consider the following DOM structure.+ *+ * ```html+ * <h3>Sign up</h3>+ * <label>+ * <input type="checkbox" /> Subscribe+ * </label>+ * <br/>+ * <button>Submit</button>+ * ```+ *+ * You can locate each element by it's implicit role:+ *+ * ```js+ * await expect(page.getByRole('heading', { name: 'Sign up' })).toBeVisible();+ *+ * await page.getByRole('checkbox', { name: 'Subscribe' }).check();+ *+ * await page.getByRole('button', { name: /submit/i }).click();+ * ```+ *+ * **Details**+ *+ * Role selector **does not replace** accessibility audits and conformance tests, but rather gives early feedback+ * about the ARIA guidelines.+ *+ * Many html elements have an implicitly [defined role](https://w3c.github.io/html-aam/#html-element-role-mappings)+ * that is recognized by the role selector. You can find all the+ * [supported roles here](https://www.w3.org/TR/wai-aria-1.2/#role_definitions). ARIA guidelines **do not recommend**+ * duplicating implicit roles and attributes by setting `role` and/or `aria-*` attributes to default values.+ * @param role Required aria role.+ * @param options+ */+ getByRole(role: "alert"|"alertdialog"|"application"|"article"|"banner"|"blockquote"|"button"|"caption"|"cell"|"checkbox"|"code"|"columnheader"|"combobox"|"complementary"|"contentinfo"|"definition"|"deletion"|"dialog"|"directory"|"document"|"emphasis"|"feed"|"figure"|"form"|"generic"|"grid"|"gridcell"|"group"|"heading"|"img"|"insertion"|"link"|"list"|"listbox"|"listitem"|"log"|"main"|"marquee"|"math"|"meter"|"menu"|"menubar"|"menuitem"|"menuitemcheckbox"|"menuitemradio"|"navigation"|"none"|"note"|"option"|"paragraph"|"presentation"|"progressbar"|"radio"|"radiogroup"|"region"|"row"|"rowgroup"|"rowheader"|"scrollbar"|"search"|"searchbox"|"separator"|"slider"|"spinbutton"|"status"|"strong"|"subscript"|"superscript"|"switch"|"tab"|"table"|"tablist"|"tabpanel"|"term"|"textbox"|"time"|"timer"|"toolbar"|"tooltip"|"tree"|"treegrid"|"treeitem", options?: {+ /**+ * An attribute that is usually set by `aria-checked` or native `<input type=checkbox>` controls.+ *+ * Learn more about [`aria-checked`](https://www.w3.org/TR/wai-aria-1.2/#aria-checked).+ */+ checked?: boolean;++ /**+ * An attribute that is usually set by `aria-disabled` or `disabled`.+ *+ * **NOTE** Unlike most other attributes, `disabled` is inherited through the DOM hierarchy. Learn more about+ * [`aria-disabled`](https://www.w3.org/TR/wai-aria-1.2/#aria-disabled).+ *+ */+ disabled?: boolean;++ /**+ * Whether [`name`](https://playwright.dev/docs/api/class-locator#locator-get-by-role-option-name) is matched exactly:+ * case-sensitive and whole-string. Defaults to false. Ignored when+ * [`name`](https://playwright.dev/docs/api/class-locator#locator-get-by-role-option-name) is a regular expression.+ * Note that exact match still trims whitespace.+ */+ exact?: boolean;++ /**+ * An attribute that is usually set by `aria-expanded`.+ *+ * Learn more about [`aria-expanded`](https://www.w3.org/TR/wai-aria-1.2/#aria-expanded).+ */+ expanded?: boolean;++ /**+ * Option that controls whether hidden elements are matched. By default, only non-hidden elements, as+ * [defined by ARIA](https://www.w3.org/TR/wai-aria-1.2/#tree_exclusion), are matched by role selector.+ *+ * Learn more about [`aria-hidden`](https://www.w3.org/TR/wai-aria-1.2/#aria-hidden).+ */+ includeHidden?: boolean;++ /**+ * A number attribute that is usually present for roles `heading`, `listitem`, `row`, `treeitem`, with default values+ * for `<h1>-<h6>` elements.+ *+ * Learn more about [`aria-level`](https://www.w3.org/TR/wai-aria-1.2/#aria-level).+ */+ level?: number;++ /**+ * Option to match the [accessible name](https://w3c.github.io/accname/#dfn-accessible-name). By default, matching is+ * case-insensitive and searches for a substring, use+ * [`exact`](https://playwright.dev/docs/api/class-locator#locator-get-by-role-option-exact) to control this behavior.+ *+ * Learn more about [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).+ */+ name?: string|RegExp;++ /**+ * An attribute that is usually set by `aria-pressed`.+ *+ * Learn more about [`aria-pressed`](https://www.w3.org/TR/wai-aria-1.2/#aria-pressed).+ */+ pressed?: boolean;++ /**+ * An attribute that is usually set by `aria-selected`.+ *+ * Learn more about [`aria-selected`](https://www.w3.org/TR/wai-aria-1.2/#aria-selected).+ */+ selected?: boolean;+ }): Locator;++ /**+ * Locate element by the test id.+ *+ * **Usage**+ *+ * Consider the following DOM structure.+ *+ * ```html+ * <button data-testid="directions">Itinéraire</button>+ * ```+ *+ * You can locate the element by it's test id:+ *+ * ```js+ * await page.getByTestId('directions').click();+ * ```+ *+ * **Details**+ *+ * By default, the `data-testid` attribute is used as a test id. Use+ * [selectors.setTestIdAttribute(attributeName)](https://playwright.dev/docs/api/class-selectors#selectors-set-test-id-attribute)+ * to configure a different test id attribute if necessary.+ *+ * ```js+ * // Set custom test id attribute from @playwright/test config:+ * import { defineConfig } from '@playwright/test';+ *+ * export default defineConfig({+ * use: {+ * testIdAttribute: 'data-pw'+ * },+ * });+ * ```+ *+ * @param testId Id to locate the element by.+ */+ getByTestId(testId: string|RegExp): Locator;++ /**+ * Allows locating elements that contain given text.+ *+ * See also [locator.filter([options])](https://playwright.dev/docs/api/class-locator#locator-filter) that allows to+ * match by another criteria, like an accessible role, and then filter by the text content.+ *+ * **Usage**+ *+ * Consider the following DOM structure:+ *+ * ```html+ * <div>Hello <span>world</span></div>+ * <div>Hello</div>+ * ```+ *+ * You can locate by text substring, exact string, or a regular expression:+ *+ * ```js+ * // Matches <span>+ * page.getByText('world');+ *+ * // Matches first <div>+ * page.getByText('Hello world');+ *+ * // Matches second <div>+ * page.getByText('Hello', { exact: true });+ *+ * // Matches both <div>s+ * page.getByText(/Hello/);+ *+ * // Matches second <div>+ * page.getByText(/^hello$/i);+ * ```+ *+ * **Details**+ *+ * Matching by text always normalizes whitespace, even with exact match. For example, it turns multiple spaces into+ * one, turns line breaks into spaces and ignores leading and trailing whitespace.+ *+ * Input elements of the type `button` and `submit` are matched by their `value` instead of the text content. For+ * example, locating by text `"Log in"` matches `<input type=button value="Log in">`.+ * @param text Text to locate the element for.+ * @param options+ */+ getByText(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating elements by their title attribute.+ *+ * **Usage**+ *+ * Consider the following DOM structure.+ *+ * ```html+ * <span title='Issues count'>25 issues</span>+ * ```+ *+ * You can check the issues count after locating it by the title text:+ *+ * ```js+ * await expect(page.getByTitle('Issues count')).toHaveText('25 issues');+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByTitle(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Highlight the corresponding element(s) on the screen. Useful for debugging, don't commit the code that uses+ * [locator.highlight()](https://playwright.dev/docs/api/class-locator#locator-highlight).+ */+ highlight(): Promise<void>;++ /**+ * Hover over the matching element.+ *+ * **Usage**+ *+ * ```js+ * await page.getByRole('link').hover();+ * ```+ *+ * **Details**+ *+ * This method hovers over the element by performing the following steps:+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the element, unless+ * [`force`](https://playwright.dev/docs/api/class-locator#locator-hover-option-force) option is set.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to hover over the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-locator#locator-hover-option-position).+ *+ * If the element is detached from the DOM at any moment during the action, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-locator#locator-hover-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param options+ */+ hover(options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard+ * `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys+ * are pressed.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * Returns the [`element.innerHTML`](https://developer.mozilla.org/en-US/docs/Web/API/Element/innerHTML).+ * @param options+ */+ innerHTML(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<string>;++ /**+ * Returns the [`element.innerText`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/innerText).+ *+ * **NOTE** If you need to assert text on the page, prefer+ * [expect(locator).toHaveText(expected[, options])](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-have-text)+ * with+ * [`useInnerText`](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-have-text-option-use-inner-text)+ * option to avoid flakiness. See [assertions guide](https://playwright.dev/docs/test-assertions) for more details.+ *+ * @param options+ */+ innerText(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<string>;++ /**+ * Returns the value for the matching `<input>` or `<textarea>` or `<select>` element.+ *+ * **NOTE** If you need to assert input value, prefer+ * [expect(locator).toHaveValue(value[, options])](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-have-value)+ * to avoid flakiness. See [assertions guide](https://playwright.dev/docs/test-assertions) for more details.+ *+ * **Usage**+ *+ * ```js+ * const value = await page.getByRole('textbox').inputValue();+ * ```+ *+ * **Details**+ *+ * Throws elements that are not an input, textarea or a select. However, if the element is inside the `<label>`+ * element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), returns the value of the+ * control.+ * @param options+ */+ inputValue(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<string>;++ /**+ * Returns whether the element is checked. Throws if the element is not a checkbox or radio input.+ *+ * **NOTE** If you need to assert that checkbox is checked, prefer+ * [expect(locator).toBeChecked([options])](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-be-checked)+ * to avoid flakiness. See [assertions guide](https://playwright.dev/docs/test-assertions) for more details.+ *+ * **Usage**+ *+ * ```js+ * const checked = await page.getByRole('checkbox').isChecked();+ * ```+ *+ * @param options+ */+ isChecked(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/docs/actionability#enabled).+ *+ * **NOTE** If you need to assert that an element is disabled, prefer+ * [expect(locator).toBeDisabled([options])](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-be-disabled)+ * to avoid flakiness. See [assertions guide](https://playwright.dev/docs/test-assertions) for more details.+ *+ * **Usage**+ *+ * ```js+ * const disabled = await page.getByRole('button').isDisabled();+ * ```+ *+ * @param options+ */+ isDisabled(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * Returns whether the element is [editable](https://playwright.dev/docs/actionability#editable). If the target element is not an `<input>`,+ * `<textarea>`, `<select>`, `[contenteditable]` and does not have a role allowing `[aria-readonly]`, this method+ * throws an error.+ *+ * **NOTE** If you need to assert that an element is editable, prefer+ * [expect(locator).toBeEditable([options])](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-be-editable)+ * to avoid flakiness. See [assertions guide](https://playwright.dev/docs/test-assertions) for more details.+ *+ * **Usage**+ *+ * ```js+ * const editable = await page.getByRole('textbox').isEditable();+ * ```+ *+ * @param options+ */+ isEditable(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * Returns whether the element is [enabled](https://playwright.dev/docs/actionability#enabled).+ *+ * **NOTE** If you need to assert that an element is enabled, prefer+ * [expect(locator).toBeEnabled([options])](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-be-enabled)+ * to avoid flakiness. See [assertions guide](https://playwright.dev/docs/test-assertions) for more details.+ *+ * **Usage**+ *+ * ```js+ * const enabled = await page.getByRole('button').isEnabled();+ * ```+ *+ * @param options+ */+ isEnabled(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/docs/actionability#visible).+ *+ * **NOTE** If you need to assert that element is hidden, prefer+ * [expect(locator).toBeHidden([options])](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-be-hidden)+ * to avoid flakiness. See [assertions guide](https://playwright.dev/docs/test-assertions) for more details.+ *+ * **Usage**+ *+ * ```js+ * const hidden = await page.getByRole('button').isHidden();+ * ```+ *+ * @param options+ */+ isHidden(options?: {+ /**+ * @deprecated This option is ignored.+ * [locator.isHidden([options])](https://playwright.dev/docs/api/class-locator#locator-is-hidden) does not wait for+ * the element to become hidden and returns immediately.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * Returns whether the element is [visible](https://playwright.dev/docs/actionability#visible).+ *+ * **NOTE** If you need to assert that element is visible, prefer+ * [expect(locator).toBeVisible([options])](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-be-visible)+ * to avoid flakiness. See [assertions guide](https://playwright.dev/docs/test-assertions) for more details.+ *+ * **Usage**+ *+ * ```js+ * const visible = await page.getByRole('button').isVisible();+ * ```+ *+ * @param options+ */+ isVisible(options?: {+ /**+ * @deprecated This option is ignored.+ * [locator.isVisible([options])](https://playwright.dev/docs/api/class-locator#locator-is-visible) does not wait for+ * the element to become visible and returns immediately.+ */+ timeout?: number;+ }): Promise<boolean>;++ /**+ * Returns locator to the last matching element.+ *+ * **Usage**+ *+ * ```js+ * const banana = await page.getByRole('listitem').last();+ * ```+ *+ */+ last(): Locator;++ /**+ * The method finds an element matching the specified selector in the locator's subtree. It also accepts filter+ * options, similar to [locator.filter([options])](https://playwright.dev/docs/api/class-locator#locator-filter)+ * method.+ *+ * [Learn more about locators](https://playwright.dev/docs/locators).+ * @param selectorOrLocator A selector or locator to use when resolving DOM element.+ * @param options+ */+ locator(selectorOrLocator: string|Locator, options?: {+ /**+ * Narrows down the results of the method to those which contain elements matching this relative locator. For example,+ * `article` that has `text=Playwright` matches `<article><div>Playwright</div></article>`.+ *+ * Inner locator **must be relative** to the outer locator and is queried starting with the outer locator match, not+ * the document root. For example, you can find `content` that has `div` in+ * `<article><content><div>Playwright</div></content></article>`. However, looking for `content` that has `article+ * div` will fail, because the inner locator must be relative and should not use any elements outside the `content`.+ *+ * Note that outer and inner locators must belong to the same frame. Inner locator must not contain+ * [FrameLocator](https://playwright.dev/docs/api/class-framelocator)s.+ */+ has?: Locator;++ /**+ * Matches elements that do not contain an element that matches an inner locator. Inner locator is queried against the+ * outer one. For example, `article` that does not have `div` matches `<article><span>Playwright</span></article>`.+ *+ * Note that outer and inner locators must belong to the same frame. Inner locator must not contain+ * [FrameLocator](https://playwright.dev/docs/api/class-framelocator)s.+ */+ hasNot?: Locator;++ /**+ * Matches elements that do not contain specified text somewhere inside, possibly in a child or a descendant element.+ * When passed a [string], matching is case-insensitive and searches for a substring.+ */+ hasNotText?: string|RegExp;++ /**+ * Matches elements containing specified text somewhere inside, possibly in a child or a descendant element. When+ * passed a [string], matching is case-insensitive and searches for a substring. For example, `"Playwright"` matches+ * `<article><div>Playwright</div></article>`.+ */+ hasText?: string|RegExp;+ }): Locator;++ /**+ * Returns locator to the n-th matching element. It's zero based, `nth(0)` selects the first element.+ *+ * **Usage**+ *+ * ```js+ * const banana = await page.getByRole('listitem').nth(2);+ * ```+ *+ * @param index+ */+ nth(index: number): Locator;++ /**+ * Creates a locator matching all elements that match one or both of the two locators.+ *+ * Note that when both locators match something, the resulting locator will have multiple matches, potentially causing+ * a [locator strictness](https://playwright.dev/docs/locators#strictness) violation.+ *+ * **Usage**+ *+ * Consider a scenario where you'd like to click on a "New email" button, but sometimes a security settings dialog+ * shows up instead. In this case, you can wait for either a "New email" button, or a dialog and act accordingly.+ *+ * **NOTE** If both "New email" button and security dialog appear on screen, the "or" locator will match both of them,+ * possibly throwing the ["strict mode violation" error](https://playwright.dev/docs/locators#strictness). In this case, you can use+ * [locator.first()](https://playwright.dev/docs/api/class-locator#locator-first) to only match one of them.+ *+ * ```js+ * const newEmail = page.getByRole('button', { name: 'New' });+ * const dialog = page.getByText('Confirm security settings');+ * await expect(newEmail.or(dialog).first()).toBeVisible();+ * if (await dialog.isVisible())+ * await page.getByRole('button', { name: 'Dismiss' }).click();+ * await newEmail.click();+ * ```+ *+ * @param locator Alternative locator to match.+ */+ or(locator: Locator): Locator;++ /**+ * A page this locator belongs to.+ */+ page(): Page;++ /**+ * Focuses the matching element and presses a combination of the keys.+ *+ * **Usage**+ *+ * ```js+ * await page.getByRole('textbox').press('Backspace');+ * ```+ *+ * **Details**+ *+ * Focuses the element, and then uses+ * [keyboard.down(key)](https://playwright.dev/docs/api/class-keyboard#keyboard-down) and+ * [keyboard.up(key)](https://playwright.dev/docs/api/class-keyboard#keyboard-up).+ *+ * [`key`](https://playwright.dev/docs/api/class-locator#locator-press-option-key) can specify the intended+ * [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) value or a single character+ * to generate the text for. A superset of the+ * [`key`](https://playwright.dev/docs/api/class-locator#locator-press-option-key) values can be found+ * [here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:+ *+ * `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`,+ * `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,+ * etc.+ *+ * Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,+ * `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.+ *+ * Holding down `Shift` will type the text that corresponds to the+ * [`key`](https://playwright.dev/docs/api/class-locator#locator-press-option-key) in the upper case.+ *+ * If [`key`](https://playwright.dev/docs/api/class-locator#locator-press-option-key) is a single character, it is+ * case-sensitive, so the values `a` and `A` will generate different respective texts.+ *+ * Shortcuts such as `key: "Control+o"`, `key: "Control++` or `key: "Control+Shift+T"` are supported as well. When+ * specified with the modifier, modifier is pressed and being held while the subsequent key is being pressed.+ * @param key Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.+ * @param options+ */+ press(key: string, options?: {+ /**+ * Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You+ * can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as+ * navigating to inaccessible pages. Defaults to `false`.+ * @deprecated This option will default to `true` in the future.+ */+ noWaitAfter?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * **NOTE** In most cases, you should use+ * [locator.fill(value[, options])](https://playwright.dev/docs/api/class-locator#locator-fill) instead. You only need+ * to press keys one by one if there is special keyboard handling on the page.+ *+ * Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the+ * text.+ *+ * To press a special key, like `Control` or `ArrowDown`, use+ * [locator.press(key[, options])](https://playwright.dev/docs/api/class-locator#locator-press).+ *+ * **Usage**+ *+ * ```js+ * await locator.pressSequentially('Hello'); // Types instantly+ * await locator.pressSequentially('World', { delay: 100 }); // Types slower, like a user+ * ```+ *+ * An example of typing into a text field and then submitting the form:+ *+ * ```js+ * const locator = page.getByLabel('Password');+ * await locator.pressSequentially('my password');+ * await locator.press('Enter');+ * ```+ *+ * @param text String of characters to sequentially press into a focused element.+ * @param options+ */+ pressSequentially(text: string, options?: {+ /**+ * Time to wait between key presses in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Take a screenshot of the element matching the locator.+ *+ * **Usage**+ *+ * ```js+ * await page.getByRole('link').screenshot();+ * ```+ *+ * Disable animations and save screenshot to a file:+ *+ * ```js+ * await page.getByRole('link').screenshot({ animations: 'disabled', path: 'link.png' });+ * ```+ *+ * **Details**+ *+ * This method captures a screenshot of the page, clipped to the size and position of a particular element matching+ * the locator. If the element is covered by other elements, it will not be actually visible on the screenshot. If the+ * element is a scrollable container, only the currently scrolled content will be visible on the screenshot.+ *+ * This method waits for the [actionability](https://playwright.dev/docs/actionability) checks, then scrolls element into view before taking+ * a screenshot. If the element is detached from DOM, the method throws an error.+ *+ * Returns the buffer with the captured screenshot.+ * @param options+ */+ screenshot(options?: LocatorScreenshotOptions): Promise<Buffer>;++ /**+ * This method waits for [actionability](https://playwright.dev/docs/actionability) checks, then tries to scroll element into view, unless+ * it is completely visible as defined by+ * [IntersectionObserver](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)'s `ratio`.+ *+ * See [scrolling](https://playwright.dev/docs/input#scrolling) for alternative ways to scroll.+ * @param options+ */+ scrollIntoViewIfNeeded(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Selects option or options in `<select>`.+ *+ * **Details**+ *+ * This method waits for [actionability](https://playwright.dev/docs/actionability) checks, waits until all specified options are present in+ * the `<select>` element and selects these options.+ *+ * If the target element is not a `<select>` element, this method throws an error. However, if the element is inside+ * the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be used+ * instead.+ *+ * Returns the array of option values that have been successfully selected.+ *+ * Triggers a `change` and `input` event once all the provided options have been selected.+ *+ * **Usage**+ *+ * ```html+ * <select multiple>+ * <option value="red">Red</div>+ * <option value="green">Green</div>+ * <option value="blue">Blue</div>+ * </select>+ * ```+ *+ * ```js+ * // single selection matching the value or label+ * element.selectOption('blue');+ *+ * // single selection matching the label+ * element.selectOption({ label: 'Blue' });+ *+ * // multiple selection for red, green and blue options+ * element.selectOption(['red', 'green', 'blue']);+ * ```+ *+ * @param values Options to select. If the `<select>` has the `multiple` attribute, all matching options are selected, otherwise+ * only the first option matching one of the passed options is selected. String values are matching both values and+ * labels. Option is considered matching if all specified properties match.+ * @param options+ */+ selectOption(values: null|string|ElementHandle|ReadonlyArray<string>|{+ /**+ * Matches by `option.value`. Optional.+ */+ value?: string;++ /**+ * Matches by `option.label`. Optional.+ */+ label?: string;++ /**+ * Matches by the index. Optional.+ */+ index?: number;+ }|ReadonlyArray<ElementHandle>|ReadonlyArray<{+ /**+ * Matches by `option.value`. Optional.+ */+ value?: string;++ /**+ * Matches by `option.label`. Optional.+ */+ label?: string;++ /**+ * Matches by the index. Optional.+ */+ index?: number;+ }>, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<Array<string>>;++ /**+ * This method waits for [actionability](https://playwright.dev/docs/actionability) checks, then focuses the element and selects all its+ * text content.+ *+ * If the element is inside the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), focuses and selects text in+ * the control instead.+ * @param options+ */+ selectText(options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Set the state of a checkbox or a radio element.+ *+ * **Usage**+ *+ * ```js+ * await page.getByRole('checkbox').setChecked(true);+ * ```+ *+ * **Details**+ *+ * This method checks or unchecks an element by performing the following steps:+ * 1. Ensure that matched element is a checkbox or a radio input. If not, this method throws.+ * 1. If the element already has the right checked state, this method returns immediately.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the matched element, unless+ * [`force`](https://playwright.dev/docs/api/class-locator#locator-set-checked-option-force) option is set. If+ * the element is detached during the checks, the whole action is retried.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element.+ * 1. Ensure that the element is now checked or unchecked. If not, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-locator#locator-set-checked-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param checked Whether to check or uncheck the checkbox.+ * @param options+ */+ setChecked(checked: boolean, options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * Upload file or multiple files into `<input type=file>`. For inputs with a `[webkitdirectory]` attribute, only a+ * single directory path is supported.+ *+ * **Usage**+ *+ * ```js+ * // Select one file+ * await page.getByLabel('Upload file').setInputFiles(path.join(__dirname, 'myfile.pdf'));+ *+ * // Select multiple files+ * await page.getByLabel('Upload files').setInputFiles([+ * path.join(__dirname, 'file1.txt'),+ * path.join(__dirname, 'file2.txt'),+ * ]);+ *+ * // Select a directory+ * await page.getByLabel('Upload directory').setInputFiles(path.join(__dirname, 'mydir'));+ *+ * // Remove all the selected files+ * await page.getByLabel('Upload file').setInputFiles([]);+ *+ * // Upload buffer from memory+ * await page.getByLabel('Upload file').setInputFiles({+ * name: 'file.txt',+ * mimeType: 'text/plain',+ * buffer: Buffer.from('this is test')+ * });+ * ```+ *+ * **Details**+ *+ * Sets the value of the file input to these file paths or files. If some of the `filePaths` are relative paths, then+ * they are resolved relative to the current working directory. For empty array, clears the selected files.+ *+ * This method expects [Locator](https://playwright.dev/docs/api/class-locator) to point to an+ * [input element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input). However, if the element is inside+ * the `<label>` element that has an associated+ * [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), targets the control instead.+ * @param files+ * @param options+ */+ setInputFiles(files: string|ReadonlyArray<string>|{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }|ReadonlyArray<{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }>, options?: {+ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Perform a tap gesture on the element matching the locator.+ *+ * **Details**+ *+ * This method taps the element by performing the following steps:+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the element, unless+ * [`force`](https://playwright.dev/docs/api/class-locator#locator-tap-option-force) option is set.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.touchscreen](https://playwright.dev/docs/api/class-page#page-touchscreen) to tap the center of the+ * element, or the specified+ * [`position`](https://playwright.dev/docs/api/class-locator#locator-tap-option-position).+ *+ * If the element is detached from the DOM at any moment during the action, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-locator#locator-tap-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ *+ * **NOTE** `element.tap()` requires that the `hasTouch` option of the browser context be set to true.+ *+ * @param options+ */+ tap(options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores+ * current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to+ * "Control" on Windows and Linux and to "Meta" on macOS.+ */+ modifiers?: Array<"Alt"|"Control"|"ControlOrMeta"|"Meta"|"Shift">;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard+ * `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys+ * are pressed.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * Returns the [`node.textContent`](https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent).+ *+ * **NOTE** If you need to assert text on the page, prefer+ * [expect(locator).toHaveText(expected[, options])](https://playwright.dev/docs/api/class-locatorassertions#locator-assertions-to-have-text)+ * to avoid flakiness. See [assertions guide](https://playwright.dev/docs/test-assertions) for more details.+ *+ * @param options+ */+ textContent(options?: {+ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<null|string>;++ /**+ * Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the+ * text.+ *+ * To press a special key, like `Control` or `ArrowDown`, use+ * [locator.press(key[, options])](https://playwright.dev/docs/api/class-locator#locator-press).+ *+ * **Usage**+ * @deprecated In most cases, you should use+ * [locator.fill(value[, options])](https://playwright.dev/docs/api/class-locator#locator-fill) instead. You only need+ * to press keys one by one if there is special keyboard handling on the page - in this case use+ * [locator.pressSequentially(text[, options])](https://playwright.dev/docs/api/class-locator#locator-press-sequentially).+ * @param text A text to type into a focused element.+ * @param options+ */+ type(text: string, options?: {+ /**+ * Time to wait between key presses in milliseconds. Defaults to 0.+ */+ delay?: number;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Ensure that checkbox or radio element is unchecked.+ *+ * **Usage**+ *+ * ```js+ * await page.getByRole('checkbox').uncheck();+ * ```+ *+ * **Details**+ *+ * This method unchecks the element by performing the following steps:+ * 1. Ensure that element is a checkbox or a radio input. If not, this method throws. If the element is already+ * unchecked, this method returns immediately.+ * 1. Wait for [actionability](https://playwright.dev/docs/actionability) checks on the element, unless+ * [`force`](https://playwright.dev/docs/api/class-locator#locator-uncheck-option-force) option is set.+ * 1. Scroll the element into view if needed.+ * 1. Use [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse) to click in the center of the+ * element.+ * 1. Ensure that the element is now unchecked. If not, this method throws.+ *+ * If the element is detached from the DOM at any moment during the action, this method throws.+ *+ * When all steps combined have not finished during the specified+ * [`timeout`](https://playwright.dev/docs/api/class-locator#locator-uncheck-option-timeout), this method throws a+ * [TimeoutError](https://playwright.dev/docs/api/class-timeouterror). Passing zero timeout disables this.+ * @param options+ */+ uncheck(options?: {+ /**+ * Whether to bypass the [actionability](https://playwright.dev/docs/actionability) checks. Defaults to `false`.+ */+ force?: boolean;++ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of+ * the element.+ */+ position?: {+ x: number;++ y: number;+ };++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * When set, this method only performs the [actionability](https://playwright.dev/docs/actionability) checks and skips the action. Defaults+ * to `false`. Useful to wait until the element is ready for the action without performing it.+ */+ trial?: boolean;+ }): Promise<void>;++ /**+ * Returns when element specified by locator satisfies the+ * [`state`](https://playwright.dev/docs/api/class-locator#locator-wait-for-option-state) option.+ *+ * If target element already satisfies the condition, the method returns immediately. Otherwise, waits for up to+ * [`timeout`](https://playwright.dev/docs/api/class-locator#locator-wait-for-option-timeout) milliseconds until the+ * condition is met.+ *+ * **Usage**+ *+ * ```js+ * const orderSent = page.locator('#order-sent');+ * await orderSent.waitFor();+ * ```+ *+ * @param options+ */+ waitFor(options?: {+ /**+ * Defaults to `'visible'`. Can be either:+ * - `'attached'` - wait for element to be present in DOM.+ * - `'detached'` - wait for element to not be present in DOM.+ * - `'visible'` - wait for element to have non-empty bounding box and no `visibility:hidden`. Note that element+ * without any content or with `display:none` has an empty bounding box and is not considered visible.+ * - `'hidden'` - wait for element to be either detached from DOM, or have an empty bounding box or+ * `visibility:hidden`. This is opposite to the `'visible'` option.+ */+ state?: "attached"|"detached"|"visible"|"hidden";++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;+}++/**+ * BrowserType provides methods to launch a specific browser instance or connect to an existing one. The following is+ * a typical example of using Playwright to drive automation:+ *+ * ```js+ * const { chromium } = require('playwright'); // Or 'firefox' or 'webkit'.+ *+ * (async () => {+ * const browser = await chromium.launch();+ * const page = await browser.newPage();+ * await page.goto('https://example.com');+ * // other actions...+ * await browser.close();+ * })();+ * ```+ *+ */+export interface BrowserType<Unused = {}> {+ /**+ * This method attaches Playwright to an existing browser instance using the Chrome DevTools Protocol.+ *+ * The default browser context is accessible via+ * [browser.contexts()](https://playwright.dev/docs/api/class-browser#browser-contexts).+ *+ * **NOTE** Connecting over the Chrome DevTools Protocol is only supported for Chromium-based browsers.+ *+ * **NOTE** This connection is significantly lower fidelity than the Playwright protocol connection via+ * [browserType.connect(wsEndpoint[, options])](https://playwright.dev/docs/api/class-browsertype#browser-type-connect).+ * If you are experiencing issues or attempting to use advanced functionality, you probably want to use+ * [browserType.connect(wsEndpoint[, options])](https://playwright.dev/docs/api/class-browsertype#browser-type-connect).+ *+ * **Usage**+ *+ * ```js+ * const browser = await playwright.chromium.connectOverCDP('http://localhost:9222');+ * const defaultContext = browser.contexts()[0];+ * const page = defaultContext.pages()[0];+ * ```+ *+ * @param endpointURL A CDP websocket endpoint or http url to connect to. For example `http://localhost:9222/` or+ * `ws://127.0.0.1:9222/devtools/browser/387adf4c-243f-4051-a181-46798f4a46f4`.+ * @param options+ */+ connectOverCDP(endpointURL: string, options?: ConnectOverCDPOptions): Promise<Browser>;+ /**+ * Option `wsEndpoint` is deprecated. Instead use `endpointURL`.+ * @deprecated+ */+ /**+ * This method attaches Playwright to an existing browser instance using the Chrome DevTools Protocol.+ *+ * The default browser context is accessible via+ * [browser.contexts()](https://playwright.dev/docs/api/class-browser#browser-contexts).+ *+ * **NOTE** Connecting over the Chrome DevTools Protocol is only supported for Chromium-based browsers.+ *+ * **NOTE** This connection is significantly lower fidelity than the Playwright protocol connection via+ * [browserType.connect(wsEndpoint[, options])](https://playwright.dev/docs/api/class-browsertype#browser-type-connect).+ * If you are experiencing issues or attempting to use advanced functionality, you probably want to use+ * [browserType.connect(wsEndpoint[, options])](https://playwright.dev/docs/api/class-browsertype#browser-type-connect).+ *+ * **Usage**+ *+ * ```js+ * const browser = await playwright.chromium.connectOverCDP('http://localhost:9222');+ * const defaultContext = browser.contexts()[0];+ * const page = defaultContext.pages()[0];+ * ```+ *+ * @param endpointURL A CDP websocket endpoint or http url to connect to. For example `http://localhost:9222/` or+ * `ws://127.0.0.1:9222/devtools/browser/387adf4c-243f-4051-a181-46798f4a46f4`.+ * @param options+ */+ connectOverCDP(options: ConnectOverCDPOptions & { wsEndpoint?: string }): Promise<Browser>;+ /**+ * This method attaches Playwright to an existing browser instance created via `BrowserType.launchServer` in Node.js.+ *+ * **NOTE** The major and minor version of the Playwright instance that connects needs to match the version of+ * Playwright that launches the browser (1.2.3 → is compatible with 1.2.x).+ *+ * @param wsEndpoint A Playwright browser websocket endpoint to connect to. You obtain this endpoint via `BrowserServer.wsEndpoint`.+ * @param options+ */+ connect(wsEndpoint: string, options?: ConnectOptions): Promise<Browser>;+ /**+ * wsEndpoint in options is deprecated. Instead use `wsEndpoint`.+ * @param wsEndpoint A browser websocket endpoint to connect to.+ * @param options+ * @deprecated+ */+ /**+ * This method attaches Playwright to an existing browser instance created via `BrowserType.launchServer` in Node.js.+ *+ * **NOTE** The major and minor version of the Playwright instance that connects needs to match the version of+ * Playwright that launches the browser (1.2.3 → is compatible with 1.2.x).+ *+ * @param wsEndpoint A Playwright browser websocket endpoint to connect to. You obtain this endpoint via `BrowserServer.wsEndpoint`.+ * @param options+ */+ connect(options: ConnectOptions & { wsEndpoint?: string }): Promise<Browser>;+ /**+ * A path where Playwright expects to find a bundled browser executable.+ */+ executablePath(): string;++ /**+ * Returns the browser instance.+ *+ * **Usage**+ *+ * You can use+ * [`ignoreDefaultArgs`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-option-ignore-default-args)+ * to filter out `--mute-audio` from default arguments:+ *+ * ```js+ * const browser = await chromium.launch({ // Or 'firefox' or 'webkit'.+ * ignoreDefaultArgs: ['--mute-audio']+ * });+ * ```+ *+ * > **Chromium-only** Playwright can also be used to control the Google Chrome or Microsoft Edge browsers, but it+ * works best with the version of Chromium it is bundled with. There is no guarantee it will work with any other+ * version. Use+ * [`executablePath`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-option-executable-path)+ * option with extreme caution.+ * >+ * > If Google Chrome (rather than Chromium) is preferred, a+ * [Chrome Canary](https://www.google.com/chrome/browser/canary.html) or+ * [Dev Channel](https://www.chromium.org/getting-involved/dev-channel) build is suggested.+ * >+ * > Stock browsers like Google Chrome and Microsoft Edge are suitable for tests that require proprietary media codecs+ * for video playback. See+ * [this article](https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/) for+ * other differences between Chromium and Chrome.+ * [This article](https://chromium.googlesource.com/chromium/src/+/lkgr/docs/chromium_browser_vs_google_chrome.md)+ * describes some differences for Linux users.+ * @param options+ */+ launch(options?: LaunchOptions): Promise<Browser>;++ /**+ * Returns the persistent browser context instance.+ *+ * Launches browser that uses persistent storage located at+ * [`userDataDir`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-persistent-context-option-user-data-dir)+ * and returns the only context. Closing this context will automatically close the browser.+ * @param userDataDir Path to a User Data Directory, which stores browser session data like cookies and local storage. More details for+ * [Chromium](https://chromium.googlesource.com/chromium/src/+/master/docs/user_data_dir.md#introduction) and+ * [Firefox](https://developer.mozilla.org/en-US/docs/Mozilla/Command_Line_Options#User_Profile). Note that Chromium's+ * user data directory is the **parent** directory of the "Profile Path" seen at `chrome://version`. Pass an empty+ * string to use a temporary directory instead.+ * @param options+ */+ launchPersistentContext(userDataDir: string, options?: {+ /**+ * Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.+ */+ acceptDownloads?: boolean;++ /**+ * An object containing an option to throw an error when API request returns status codes other than 2xx and 3xx. By+ * default, response object is returned for all status codes.+ */+ apiRequestFailsOnErrorStatus?: boolean;++ /**+ * **NOTE** Use custom browser args at your own risk, as some of them may break Playwright functionality.+ *+ * Additional arguments to pass to the browser instance. The list of Chromium flags can be found+ * [here](https://peter.sh/experiments/chromium-command-line-switches/).+ */+ args?: Array<string>;++ /**+ * When using [page.goto(url[, options])](https://playwright.dev/docs/api/class-page#page-goto),+ * [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route),+ * [page.waitForURL(url[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-url),+ * [page.waitForRequest(urlOrPredicate[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-request),+ * or+ * [page.waitForResponse(urlOrPredicate[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-response)+ * it takes the base URL in consideration by using the+ * [`URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor for building the corresponding URL.+ * Unset by default. Examples:+ * - baseURL: `http://localhost:3000` and navigating to `/bar.html` results in `http://localhost:3000/bar.html`+ * - baseURL: `http://localhost:3000/foo/` and navigating to `./bar.html` results in+ * `http://localhost:3000/foo/bar.html`+ * - baseURL: `http://localhost:3000/foo` (without trailing slash) and navigating to `./bar.html` results in+ * `http://localhost:3000/bar.html`+ */+ baseURL?: string;++ /**+ * Toggles bypassing page's Content-Security-Policy. Defaults to `false`.+ */+ bypassCSP?: boolean;++ /**+ * Browser distribution channel.+ *+ * Use "chromium" to [opt in to new headless mode](https://playwright.dev/docs/browsers#chromium-new-headless-mode).+ *+ * Use "chrome", "chrome-beta", "chrome-dev", "chrome-canary", "msedge", "msedge-beta", "msedge-dev", or+ * "msedge-canary" to use branded [Google Chrome and Microsoft Edge](https://playwright.dev/docs/browsers#google-chrome--microsoft-edge).+ */+ channel?: string;++ /**+ * Enable Chromium sandboxing. Defaults to `false`.+ */+ chromiumSandbox?: boolean;++ /**+ * TLS Client Authentication allows the server to request a client certificate and verify it.+ *+ * **Details**+ *+ * An array of client certificates to be used. Each certificate object must have either both `certPath` and `keyPath`,+ * a single `pfxPath`, or their corresponding direct value equivalents (`cert` and `key`, or `pfx`). Optionally,+ * `passphrase` property should be provided if the certificate is encrypted. The `origin` property should be provided+ * with an exact match to the request origin that the certificate is valid for.+ *+ * **NOTE** When using WebKit on macOS, accessing `localhost` will not pick up client certificates. You can make it+ * work by replacing `localhost` with `local.playwright`.+ *+ */+ clientCertificates?: Array<{+ /**+ * Exact origin that the certificate is valid for. Origin includes `https` protocol, a hostname and optionally a port.+ */+ origin: string;++ /**+ * Path to the file with the certificate in PEM format.+ */+ certPath?: string;++ /**+ * Direct value of the certificate in PEM format.+ */+ cert?: Buffer;++ /**+ * Path to the file with the private key in PEM format.+ */+ keyPath?: string;++ /**+ * Direct value of the private key in PEM format.+ */+ key?: Buffer;++ /**+ * Path to the PFX or PKCS12 encoded private key and certificate chain.+ */+ pfxPath?: string;++ /**+ * Direct value of the PFX or PKCS12 encoded private key and certificate chain.+ */+ pfx?: Buffer;++ /**+ * Passphrase for the private key (PEM or PFX).+ */+ passphrase?: string;+ }>;++ /**+ * Emulates [prefers-colors-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)+ * media feature, supported values are `'light'` and `'dark'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'light'`.+ */+ colorScheme?: null|"light"|"dark"|"no-preference";++ /**+ * Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'no-preference'`.+ */+ contrast?: null|"no-preference"|"more";++ /**+ * Specify device scale factor (can be thought of as dpr). Defaults to `1`. Learn more about+ * [emulating devices with device scale factor](https://playwright.dev/docs/emulation#devices).+ */+ deviceScaleFactor?: number;++ /**+ * **Chromium-only** Whether to auto-open a Developer Tools panel for each tab. If this option is `true`, the+ * [`headless`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-persistent-context-option-headless)+ * option will be set `false`.+ * @deprecated Use [debugging tools](https://playwright.dev/docs/debug) instead.+ */+ devtools?: boolean;++ /**+ * If specified, accepted downloads are downloaded into this directory. Otherwise, temporary directory is created and+ * is deleted when browser is closed. In either case, the downloads are deleted when the browser context they were+ * created in is closed.+ */+ downloadsPath?: string;++ /**+ * Specify environment variables that will be visible to the browser. Defaults to `process.env`.+ */+ env?: { [key: string]: string|number|boolean; };++ /**+ * Path to a browser executable to run instead of the bundled one. If+ * [`executablePath`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-persistent-context-option-executable-path)+ * is a relative path, then it is resolved relative to the current working directory. Note that Playwright only works+ * with the bundled Chromium, Firefox or WebKit, use at your own risk.+ */+ executablePath?: string;++ /**+ * An object containing additional HTTP headers to be sent with every request. Defaults to none.+ */+ extraHTTPHeaders?: { [key: string]: string; };++ /**+ * Firefox user preferences. Learn more about the Firefox user preferences at+ * [`about:config`](https://support.mozilla.org/en-US/kb/about-config-editor-firefox).+ */+ firefoxUserPrefs?: { [key: string]: string|number|boolean; };++ /**+ * Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'none'`.+ */+ forcedColors?: null|"active"|"none";++ geolocation?: {+ /**+ * Latitude between -90 and 90.+ */+ latitude: number;++ /**+ * Longitude between -180 and 180.+ */+ longitude: number;++ /**+ * Non-negative accuracy value. Defaults to `0`.+ */+ accuracy?: number;+ };++ /**+ * Close the browser process on SIGHUP. Defaults to `true`.+ */+ handleSIGHUP?: boolean;++ /**+ * Close the browser process on Ctrl-C. Defaults to `true`.+ */+ handleSIGINT?: boolean;++ /**+ * Close the browser process on SIGTERM. Defaults to `true`.+ */+ handleSIGTERM?: boolean;++ /**+ * Specifies if viewport supports touch events. Defaults to false. Learn more about+ * [mobile emulation](https://playwright.dev/docs/emulation#devices).+ */+ hasTouch?: boolean;++ /**+ * Whether to run browser in headless mode. More details for+ * [Chromium](https://developers.google.com/web/updates/2017/04/headless-chrome) and+ * [Firefox](https://developer.mozilla.org/en-US/docs/Mozilla/Firefox/Headless_mode). Defaults to `true` unless the+ * [`devtools`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-option-devtools) option is+ * `true`.+ */+ headless?: boolean;++ /**+ * Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If no+ * origin is specified, the username and password are sent to any servers upon unauthorized responses.+ */+ httpCredentials?: {+ username: string;++ password: string;++ /**+ * Restrain sending http credentials on specific origin (scheme://host:port).+ */+ origin?: string;++ /**+ * This option only applies to the requests sent from corresponding+ * [APIRequestContext](https://playwright.dev/docs/api/class-apirequestcontext) and does not affect requests sent from+ * the browser. `'always'` - `Authorization` header with basic authentication credentials will be sent with the each+ * API request. `'unauthorized` - the credentials are only sent when 401 (Unauthorized) response with+ * `WWW-Authenticate` header is received. Defaults to `'unauthorized'`.+ */+ send?: "unauthorized"|"always";+ };++ /**+ * If `true`, Playwright does not pass its own configurations args and only uses the ones from+ * [`args`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-persistent-context-option-args). If+ * an array is given, then filters out the given default arguments. Dangerous option; use with care. Defaults to+ * `false`.+ */+ ignoreDefaultArgs?: boolean|Array<string>;++ /**+ * Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.+ */+ ignoreHTTPSErrors?: boolean;++ /**+ * Whether the `meta viewport` tag is taken into account and touch events are enabled. isMobile is a part of device,+ * so you don't actually need to set it manually. Defaults to `false` and is not supported in Firefox. Learn more+ * about [mobile emulation](https://playwright.dev/docs/emulation#ismobile).+ */+ isMobile?: boolean;++ /**+ * Whether or not to enable JavaScript in the context. Defaults to `true`. Learn more about+ * [disabling JavaScript](https://playwright.dev/docs/emulation#javascript-enabled).+ */+ javaScriptEnabled?: boolean;++ /**+ * Specify user locale, for example `en-GB`, `de-DE`, etc. Locale will affect `navigator.language` value,+ * `Accept-Language` request header value as well as number and date formatting rules. Defaults to the system default+ * locale. Learn more about emulation in our [emulation guide](https://playwright.dev/docs/emulation#locale--timezone).+ */+ locale?: string;++ /**+ * Logger sink for Playwright logging.+ */+ logger?: Logger;++ /**+ * Whether to emulate network being offline. Defaults to `false`. Learn more about+ * [network emulation](https://playwright.dev/docs/emulation#offline).+ */+ offline?: boolean;++ /**+ * A list of permissions to grant to all pages in this context. See+ * [browserContext.grantPermissions(permissions[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-grant-permissions)+ * for more details. Defaults to none.+ */+ permissions?: Array<string>;++ /**+ * Network proxy settings.+ */+ proxy?: {+ /**+ * Proxy to be used for all requests. HTTP and SOCKS proxies are supported, for example `http://myproxy.com:3128` or+ * `socks5://myproxy.com:3128`. Short form `myproxy.com:3128` is considered an HTTP proxy.+ */+ server: string;++ /**+ * Optional comma-separated domains to bypass proxy, for example `".com, chromium.org, .domain.com"`.+ */+ bypass?: string;++ /**+ * Optional username to use if HTTP proxy requires authentication.+ */+ username?: string;++ /**+ * Optional password to use if HTTP proxy requires authentication.+ */+ password?: string;+ };++ /**+ * Enables [HAR](http://www.softwareishard.com/blog/har-12-spec) recording for all pages into `recordHar.path` file.+ * If not specified, the HAR is not recorded. Make sure to await+ * [browserContext.close([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-close) for+ * the HAR to be saved.+ */+ recordHar?: {+ /**+ * Optional setting to control whether to omit request content from the HAR. Defaults to `false`. Deprecated, use+ * `content` policy instead.+ */+ omitContent?: boolean;++ /**+ * Optional setting to control resource content management. If `omit` is specified, content is not persisted. If+ * `attach` is specified, resources are persisted as separate files or entries in the ZIP archive. If `embed` is+ * specified, content is stored inline the HAR file as per HAR specification. Defaults to `attach` for `.zip` output+ * files and to `embed` for all other file extensions.+ */+ content?: "omit"|"embed"|"attach";++ /**+ * Path on the filesystem to write the HAR file to. If the file name ends with `.zip`, `content: 'attach'` is used by+ * default.+ */+ path: string;++ /**+ * When set to `minimal`, only record information necessary for routing from HAR. This omits sizes, timing, page,+ * cookies, security and other types of HAR information that are not used when replaying from HAR. Defaults to `full`.+ */+ mode?: "full"|"minimal";++ /**+ * A glob or regex pattern to filter requests that are stored in the HAR. When a+ * [`baseURL`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-base-url) via the context+ * options was provided and the passed URL is a path, it gets merged via the+ * [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor. Defaults to none.+ */+ urlFilter?: string|RegExp;+ };++ /**+ * Enables video recording for all pages into `recordVideo.dir` directory. If not specified videos are not recorded.+ * Make sure to await+ * [browserContext.close([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-close) for+ * videos to be saved.+ */+ recordVideo?: {+ /**+ * Path to the directory to put videos into.+ */+ dir: string;++ /**+ * Optional dimensions of the recorded videos. If not specified the size will be equal to `viewport` scaled down to+ * fit into 800x800. If `viewport` is not configured explicitly the video size defaults to 800x450. Actual picture of+ * each page will be scaled down if necessary to fit the specified size.+ */+ size?: {+ /**+ * Video frame width.+ */+ width: number;++ /**+ * Video frame height.+ */+ height: number;+ };+ };++ /**+ * Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'no-preference'`.+ */+ reducedMotion?: null|"reduce"|"no-preference";++ /**+ * Emulates consistent window screen size available inside web page via `window.screen`. Is only used when the+ * [`viewport`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-persistent-context-option-viewport)+ * is set.+ */+ screen?: {+ /**+ * page width in pixels.+ */+ width: number;++ /**+ * page height in pixels.+ */+ height: number;+ };++ /**+ * Whether to allow sites to register Service workers. Defaults to `'allow'`.+ * - `'allow'`: [Service Workers](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) can be+ * registered.+ * - `'block'`: Playwright will block all registration of Service Workers.+ */+ serviceWorkers?: "allow"|"block";++ /**+ * Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going+ * on.+ */+ slowMo?: number;++ /**+ * If set to true, enables strict selectors mode for this context. In the strict selectors mode all operations on+ * selectors that imply single target DOM element will throw when more than one element matches the selector. This+ * option does not affect any Locator APIs (Locators are always strict). Defaults to `false`. See+ * [Locator](https://playwright.dev/docs/api/class-locator) to learn more about the strict mode.+ */+ strictSelectors?: boolean;++ /**+ * Maximum time in milliseconds to wait for the browser instance to start. Defaults to `30000` (30 seconds). Pass `0`+ * to disable timeout.+ */+ timeout?: number;++ /**+ * Changes the timezone of the context. See+ * [ICU's metaZones.txt](https://cs.chromium.org/chromium/src/third_party/icu/source/data/misc/metaZones.txt?rcl=faee8bc70570192d82d2978a71e2a615788597d1)+ * for a list of supported timezone IDs. Defaults to the system timezone.+ */+ timezoneId?: string;++ /**+ * If specified, traces are saved into this directory.+ */+ tracesDir?: string;++ /**+ * Specific user agent to use in this context.+ */+ userAgent?: string;++ /**+ * @deprecated Use+ * [`recordVideo`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-persistent-context-option-record-video)+ * instead.+ */+ videoSize?: {+ /**+ * Video frame width.+ */+ width: number;++ /**+ * Video frame height.+ */+ height: number;+ };++ /**+ * @deprecated Use+ * [`recordVideo`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-persistent-context-option-record-video)+ * instead.+ */+ videosPath?: string;++ /**+ * Emulates consistent viewport for each page. Defaults to an 1280x720 viewport. Use `null` to disable the consistent+ * viewport emulation. Learn more about [viewport emulation](https://playwright.dev/docs/emulation#viewport).+ *+ * **NOTE** The `null` value opts out from the default presets, makes viewport depend on the host window size defined+ * by the operating system. It makes the execution of the tests non-deterministic.+ *+ */+ viewport?: null|{+ /**+ * page width in pixels.+ */+ width: number;++ /**+ * page height in pixels.+ */+ height: number;+ };+ }): Promise<BrowserContext>;++ /**+ * Returns the browser app instance. You can connect to it via+ * [browserType.connect(wsEndpoint[, options])](https://playwright.dev/docs/api/class-browsertype#browser-type-connect),+ * which requires the major/minor client/server version to match (1.2.3 → is compatible with 1.2.x).+ *+ * **Usage**+ *+ * Launches browser server that client can connect to. An example of launching a browser executable and connecting to+ * it later:+ *+ * ```js+ * const { chromium } = require('playwright'); // Or 'webkit' or 'firefox'.+ *+ * (async () => {+ * const browserServer = await chromium.launchServer();+ * const wsEndpoint = browserServer.wsEndpoint();+ * // Use web socket endpoint later to establish a connection.+ * const browser = await chromium.connect(wsEndpoint);+ * // Close browser instance.+ * await browserServer.close();+ * })();+ * ```+ *+ * @param options+ */+ launchServer(options?: {+ /**+ * **NOTE** Use custom browser args at your own risk, as some of them may break Playwright functionality.+ *+ * Additional arguments to pass to the browser instance. The list of Chromium flags can be found+ * [here](https://peter.sh/experiments/chromium-command-line-switches/).+ */+ args?: Array<string>;++ /**+ * Browser distribution channel.+ *+ * Use "chromium" to [opt in to new headless mode](https://playwright.dev/docs/browsers#chromium-new-headless-mode).+ *+ * Use "chrome", "chrome-beta", "chrome-dev", "chrome-canary", "msedge", "msedge-beta", "msedge-dev", or+ * "msedge-canary" to use branded [Google Chrome and Microsoft Edge](https://playwright.dev/docs/browsers#google-chrome--microsoft-edge).+ */+ channel?: string;++ /**+ * Enable Chromium sandboxing. Defaults to `false`.+ */+ chromiumSandbox?: boolean;++ /**+ * **Chromium-only** Whether to auto-open a Developer Tools panel for each tab. If this option is `true`, the+ * [`headless`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-server-option-headless) option+ * will be set `false`.+ * @deprecated Use [debugging tools](https://playwright.dev/docs/debug) instead.+ */+ devtools?: boolean;++ /**+ * If specified, accepted downloads are downloaded into this directory. Otherwise, temporary directory is created and+ * is deleted when browser is closed. In either case, the downloads are deleted when the browser context they were+ * created in is closed.+ */+ downloadsPath?: string;++ /**+ * Specify environment variables that will be visible to the browser. Defaults to `process.env`.+ */+ env?: { [key: string]: string|number|boolean; };++ /**+ * Path to a browser executable to run instead of the bundled one. If+ * [`executablePath`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-server-option-executable-path)+ * is a relative path, then it is resolved relative to the current working directory. Note that Playwright only works+ * with the bundled Chromium, Firefox or WebKit, use at your own risk.+ */+ executablePath?: string;++ /**+ * Firefox user preferences. Learn more about the Firefox user preferences at+ * [`about:config`](https://support.mozilla.org/en-US/kb/about-config-editor-firefox).+ */+ firefoxUserPrefs?: { [key: string]: string|number|boolean; };++ /**+ * Close the browser process on SIGHUP. Defaults to `true`.+ */+ handleSIGHUP?: boolean;++ /**+ * Close the browser process on Ctrl-C. Defaults to `true`.+ */+ handleSIGINT?: boolean;++ /**+ * Close the browser process on SIGTERM. Defaults to `true`.+ */+ handleSIGTERM?: boolean;++ /**+ * Whether to run browser in headless mode. More details for+ * [Chromium](https://developers.google.com/web/updates/2017/04/headless-chrome) and+ * [Firefox](https://developer.mozilla.org/en-US/docs/Mozilla/Firefox/Headless_mode). Defaults to `true` unless the+ * [`devtools`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-option-devtools) option is+ * `true`.+ */+ headless?: boolean;++ /**+ * Host to use for the web socket. It is optional and if it is omitted, the server will accept connections on the+ * unspecified IPv6 address (::) when IPv6 is available, or the unspecified IPv4 address (0.0.0.0) otherwise. Consider+ * hardening it with picking a specific interface.+ */+ host?: string;++ /**+ * If `true`, Playwright does not pass its own configurations args and only uses the ones from+ * [`args`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-server-option-args). If an array is+ * given, then filters out the given default arguments. Dangerous option; use with care. Defaults to `false`.+ */+ ignoreDefaultArgs?: boolean|Array<string>;++ /**+ * Logger sink for Playwright logging.+ */+ logger?: Logger;++ /**+ * Port to use for the web socket. Defaults to 0 that picks any available port.+ */+ port?: number;++ /**+ * Network proxy settings.+ */+ proxy?: {+ /**+ * Proxy to be used for all requests. HTTP and SOCKS proxies are supported, for example `http://myproxy.com:3128` or+ * `socks5://myproxy.com:3128`. Short form `myproxy.com:3128` is considered an HTTP proxy.+ */+ server: string;++ /**+ * Optional comma-separated domains to bypass proxy, for example `".com, chromium.org, .domain.com"`.+ */+ bypass?: string;++ /**+ * Optional username to use if HTTP proxy requires authentication.+ */+ username?: string;++ /**+ * Optional password to use if HTTP proxy requires authentication.+ */+ password?: string;+ };++ /**+ * Maximum time in milliseconds to wait for the browser instance to start. Defaults to `30000` (30 seconds). Pass `0`+ * to disable timeout.+ */+ timeout?: number;++ /**+ * If specified, traces are saved into this directory.+ */+ tracesDir?: string;++ /**+ * Path at which to serve the Browser Server. For security, this defaults to an unguessable string.+ *+ * **NOTE** Any process or web page (including those running in Playwright) with knowledge of the `wsPath` can take+ * control of the OS user. For this reason, you should use an unguessable token when using this option.+ *+ */+ wsPath?: string;+ }): Promise<BrowserServer>;++ /**+ * Returns browser name. For example: `'chromium'`, `'webkit'` or `'firefox'`.+ */+ name(): string;+}++/**+ * The `CDPSession` instances are used to talk raw Chrome Devtools Protocol:+ * - protocol methods can be called with `session.send` method.+ * - protocol events can be subscribed to with `session.on` method.+ *+ * Useful links:+ * - Documentation on DevTools Protocol can be found here:+ * [DevTools Protocol Viewer](https://chromedevtools.github.io/devtools-protocol/).+ * - Getting Started with DevTools Protocol:+ * https://github.com/aslushnikov/getting-started-with-cdp/blob/master/README.md+ *+ * ```js+ * const client = await page.context().newCDPSession(page);+ * await client.send('Animation.enable');+ * client.on('Animation.animationCreated', () => console.log('Animation created!'));+ * const response = await client.send('Animation.getPlaybackRate');+ * console.log('playback rate is ' + response.playbackRate);+ * await client.send('Animation.setPlaybackRate', {+ * playbackRate: response.playbackRate / 2+ * });+ * ```+ *+ */+export interface CDPSession {+ on: <T extends keyof Protocol.Events | symbol>(event: T, listener: (payload: T extends symbol ? any : Protocol.Events[T extends keyof Protocol.Events ? T : never]) => void) => this;+ addListener: <T extends keyof Protocol.Events | symbol>(event: T, listener: (payload: T extends symbol ? any : Protocol.Events[T extends keyof Protocol.Events ? T : never]) => void) => this;+ off: <T extends keyof Protocol.Events | symbol>(event: T, listener: (payload: T extends symbol ? any : Protocol.Events[T extends keyof Protocol.Events ? T : never]) => void) => this;+ removeListener: <T extends keyof Protocol.Events | symbol>(event: T, listener: (payload: T extends symbol ? any : Protocol.Events[T extends keyof Protocol.Events ? T : never]) => void) => this;+ once: <T extends keyof Protocol.Events | symbol>(event: T, listener: (payload: T extends symbol ? any : Protocol.Events[T extends keyof Protocol.Events ? T : never]) => void) => this;+ /**+ * @param method Protocol method name.+ * @param params Optional method parameters.+ */+ send<T extends keyof Protocol.CommandParameters>(+ method: T,+ params?: Protocol.CommandParameters[T]+ ): Promise<Protocol.CommandReturnValues[T]>;+ /**+ * Detaches the CDPSession from the target. Once detached, the CDPSession object won't emit any events and can't be+ * used to send messages.+ */+ detach(): Promise<void>;+}++/**+ * Whenever a [`WebSocket`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) route is set up with+ * [page.routeWebSocket(url, handler)](https://playwright.dev/docs/api/class-page#page-route-web-socket) or+ * [browserContext.routeWebSocket(url, handler)](https://playwright.dev/docs/api/class-browsercontext#browser-context-route-web-socket),+ * the `WebSocketRoute` object allows to handle the WebSocket, like an actual server would do.+ *+ * **Mocking**+ *+ * By default, the routed WebSocket will not connect to the server. This way, you can mock entire communcation over+ * the WebSocket. Here is an example that responds to a `"request"` with a `"response"`.+ *+ * ```js+ * await page.routeWebSocket('wss://example.com/ws', ws => {+ * ws.onMessage(message => {+ * if (message === 'request')+ * ws.send('response');+ * });+ * });+ * ```+ *+ * Since we do not call+ * [webSocketRoute.connectToServer()](https://playwright.dev/docs/api/class-websocketroute#web-socket-route-connect-to-server)+ * inside the WebSocket route handler, Playwright assumes that WebSocket will be mocked, and opens the WebSocket+ * inside the page automatically.+ *+ * Here is another example that handles JSON messages:+ *+ * ```js+ * await page.routeWebSocket('wss://example.com/ws', ws => {+ * ws.onMessage(message => {+ * const json = JSON.parse(message);+ * if (json.request === 'question')+ * ws.send(JSON.stringify({ response: 'answer' }));+ * });+ * });+ * ```+ *+ * **Intercepting**+ *+ * Alternatively, you may want to connect to the actual server, but intercept messages in-between and modify or block+ * them. Calling+ * [webSocketRoute.connectToServer()](https://playwright.dev/docs/api/class-websocketroute#web-socket-route-connect-to-server)+ * returns a server-side `WebSocketRoute` instance that you can send messages to, or handle incoming messages.+ *+ * Below is an example that modifies some messages sent by the page to the server. Messages sent from the server to+ * the page are left intact, relying on the default forwarding.+ *+ * ```js+ * await page.routeWebSocket('/ws', ws => {+ * const server = ws.connectToServer();+ * ws.onMessage(message => {+ * if (message === 'request')+ * server.send('request2');+ * else+ * server.send(message);+ * });+ * });+ * ```+ *+ * After connecting to the server, all **messages are forwarded** between the page and the server by default.+ *+ * However, if you call+ * [webSocketRoute.onMessage(handler)](https://playwright.dev/docs/api/class-websocketroute#web-socket-route-on-message)+ * on the original route, messages from the page to the server **will not be forwarded** anymore, but should instead+ * be handled by the+ * [`handler`](https://playwright.dev/docs/api/class-websocketroute#web-socket-route-on-message-option-handler).+ *+ * Similarly, calling+ * [webSocketRoute.onMessage(handler)](https://playwright.dev/docs/api/class-websocketroute#web-socket-route-on-message)+ * on the server-side WebSocket will **stop forwarding messages** from the server to the page, and+ * [`handler`](https://playwright.dev/docs/api/class-websocketroute#web-socket-route-on-message-option-handler) should+ * take care of them.+ *+ * The following example blocks some messages in both directions. Since it calls+ * [webSocketRoute.onMessage(handler)](https://playwright.dev/docs/api/class-websocketroute#web-socket-route-on-message)+ * in both directions, there is no automatic forwarding at all.+ *+ * ```js+ * await page.routeWebSocket('/ws', ws => {+ * const server = ws.connectToServer();+ * ws.onMessage(message => {+ * if (message !== 'blocked-from-the-page')+ * server.send(message);+ * });+ * server.onMessage(message => {+ * if (message !== 'blocked-from-the-server')+ * ws.send(message);+ * });+ * });+ * ```+ *+ */+export interface WebSocketRoute {+ /**+ * This method allows to handle messages that are sent by the WebSocket, either from the page or from the server.+ *+ * When called on the original WebSocket route, this method handles messages sent from the page. You can handle this+ * messages by responding to them with+ * [webSocketRoute.send(message)](https://playwright.dev/docs/api/class-websocketroute#web-socket-route-send),+ * forwarding them to the server-side connection returned by+ * [webSocketRoute.connectToServer()](https://playwright.dev/docs/api/class-websocketroute#web-socket-route-connect-to-server)+ * or do something else.+ *+ * Once this method is called, messages are not automatically forwarded to the server or to the page - you should do+ * that manually by calling+ * [webSocketRoute.send(message)](https://playwright.dev/docs/api/class-websocketroute#web-socket-route-send). See+ * examples at the top for more details.+ *+ * Calling this method again will override the handler with a new one.+ * @param handler Function that will handle messages.+ */+ onMessage(handler: (message: string | Buffer) => any): void;+ /**+ * Allows to handle [`WebSocket.close`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close).+ *+ * By default, closing one side of the connection, either in the page or on the server, will close the other side.+ * However, when+ * [webSocketRoute.onClose(handler)](https://playwright.dev/docs/api/class-websocketroute#web-socket-route-on-close)+ * handler is set up, the default forwarding of closure is disabled, and handler should take care of it.+ * @param handler Function that will handle WebSocket closure. Received an optional+ * [close code](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#code) and an optional+ * [close reason](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#reason).+ */+ onClose(handler: (code: number | undefined, reason: string | undefined) => any): void;+ /**+ * Closes one side of the WebSocket connection.+ * @param options+ */+ close(options?: {+ /**+ * Optional [close code](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#code).+ */+ code?: number;++ /**+ * Optional [close reason](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#reason).+ */+ reason?: string;+ }): Promise<void>;++ /**+ * By default, routed WebSocket does not connect to the server, so you can mock entire WebSocket communication. This+ * method connects to the actual WebSocket server, and returns the server-side+ * [WebSocketRoute](https://playwright.dev/docs/api/class-websocketroute) instance, giving the ability to send and+ * receive messages from the server.+ *+ * Once connected to the server:+ * - Messages received from the server will be **automatically forwarded** to the WebSocket in the page, unless+ * [webSocketRoute.onMessage(handler)](https://playwright.dev/docs/api/class-websocketroute#web-socket-route-on-message)+ * is called on the server-side `WebSocketRoute`.+ * - Messages sent by the [`WebSocket.send()`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send) call+ * in the page will be **automatically forwarded** to the server, unless+ * [webSocketRoute.onMessage(handler)](https://playwright.dev/docs/api/class-websocketroute#web-socket-route-on-message)+ * is called on the original `WebSocketRoute`.+ *+ * See examples at the top for more details.+ */+ connectToServer(): WebSocketRoute;++ /**+ * Sends a message to the WebSocket. When called on the original WebSocket, sends the message to the page. When called+ * on the result of+ * [webSocketRoute.connectToServer()](https://playwright.dev/docs/api/class-websocketroute#web-socket-route-connect-to-server),+ * sends the message to the server. See examples at the top for more details.+ * @param message Message to send.+ */+ send(message: string|Buffer): void;++ /**+ * URL of the WebSocket created in the page.+ */+ url(): string;++ [Symbol.asyncDispose](): Promise<void>;+}++type DeviceDescriptor = {+ viewport: ViewportSize;+ userAgent: string;+ deviceScaleFactor: number;+ isMobile: boolean;+ hasTouch: boolean;+ defaultBrowserType: 'chromium' | 'firefox' | 'webkit';+};++export namespace errors {++/**+ * - extends: [Error]+ *+ * TimeoutError is emitted whenever certain operations are terminated due to timeout, e.g.+ * [locator.waitFor([options])](https://playwright.dev/docs/api/class-locator#locator-wait-for) or+ * [browserType.launch([options])](https://playwright.dev/docs/api/class-browsertype#browser-type-launch).+ *+ * ```js+ * const playwright = require('playwright');+ *+ * (async () => {+ * const browser = await playwright.chromium.launch();+ * const context = await browser.newContext();+ * const page = await context.newPage();+ * try {+ * await page.locator('text=Foo').click({+ * timeout: 100,+ * });+ * } catch (error) {+ * if (error instanceof playwright.errors.TimeoutError)+ * console.log('Timeout!');+ * }+ * await browser.close();+ * })();+ * ```+ *+ */+class TimeoutError extends Error {+}++}++/**+ * The Accessibility class provides methods for inspecting Chromium's accessibility tree. The accessibility tree is+ * used by assistive technology such as [screen readers](https://en.wikipedia.org/wiki/Screen_reader) or+ * [switches](https://en.wikipedia.org/wiki/Switch_access).+ *+ * Accessibility is a very platform-specific thing. On different platforms, there are different screen readers that+ * might have wildly different output.+ *+ * Rendering engines of Chromium, Firefox and WebKit have a concept of "accessibility tree", which is then translated+ * into different platform-specific APIs. Accessibility namespace gives access to this Accessibility Tree.+ *+ * Most of the accessibility tree gets filtered out when converting from internal browser AX Tree to Platform-specific+ * AX-Tree or by assistive technologies themselves. By default, Playwright tries to approximate this filtering,+ * exposing only the "interesting" nodes of the tree.+ */+export interface Accessibility {+ /**+ * Captures the current state of the accessibility tree. The returned object represents the root accessible node of+ * the page.+ *+ * **NOTE** The Chromium accessibility tree contains nodes that go unused on most platforms and by most screen+ * readers. Playwright will discard them as well for an easier to process tree, unless+ * [`interestingOnly`](https://playwright.dev/docs/api/class-accessibility#accessibility-snapshot-option-interesting-only)+ * is set to `false`.+ *+ * **Usage**+ *+ * An example of dumping the entire accessibility tree:+ *+ * ```js+ * const snapshot = await page.accessibility.snapshot();+ * console.log(snapshot);+ * ```+ *+ * An example of logging the focused node's name:+ *+ * ```js+ * const snapshot = await page.accessibility.snapshot();+ * const node = findFocusedNode(snapshot);+ * console.log(node && node.name);+ *+ * function findFocusedNode(node) {+ * if (node.focused)+ * return node;+ * for (const child of node.children || []) {+ * const foundNode = findFocusedNode(child);+ * if (foundNode)+ * return foundNode;+ * }+ * return null;+ * }+ * ```+ *+ * @deprecated This method is deprecated. Please use other libraries such as [Axe](https://www.deque.com/axe/) if you need to test+ * page accessibility. See our Node.js [guide](https://playwright.dev/docs/accessibility-testing) for integration with+ * Axe.+ * @param options+ */+ snapshot(options?: AccessibilitySnapshotOptions): Promise<null|AccessibilityNode>;++}++type AccessibilityNode = {+ role: string;+ name: string;+ value?: string|number;+ description?: string;+ keyshortcuts?: string;+ roledescription?: string;+ valuetext?: string;+ disabled?: boolean;+ expanded?: boolean;+ focused?: boolean;+ modal?: boolean;+ multiline?: boolean;+ multiselectable?: boolean;+ readonly?: boolean;+ required?: boolean;+ selected?: boolean;+ checked?: boolean|"mixed";+ pressed?: boolean|"mixed";+ level?: number;+ valuemin?: number;+ valuemax?: number;+ autocomplete?: string;+ haspopup?: string;+ invalid?: string;+ orientation?: string;+ children?: AccessibilityNode[];+}++export const devices: Devices;++//@ts-ignore this will be any if electron is not installed+type ElectronType = typeof import('electron');++/**+ * Electron application representation. You can use+ * [electron.launch([options])](https://playwright.dev/docs/api/class-electron#electron-launch) to obtain the+ * application instance. This instance you can control main electron process as well as work with Electron windows:+ *+ * ```js+ * const { _electron: electron } = require('playwright');+ *+ * (async () => {+ * // Launch Electron app.+ * const electronApp = await electron.launch({ args: ['main.js'] });+ *+ * // Evaluation expression in the Electron context.+ * const appPath = await electronApp.evaluate(async ({ app }) => {+ * // This runs in the main Electron process, parameter here is always+ * // the result of the require('electron') in the main app script.+ * return app.getAppPath();+ * });+ * console.log(appPath);+ *+ * // Get the first window that the app opens, wait if necessary.+ * const window = await electronApp.firstWindow();+ * // Print the title.+ * console.log(await window.title());+ * // Capture a screenshot.+ * await window.screenshot({ path: 'intro.png' });+ * // Direct Electron console to Node terminal.+ * window.on('console', console.log);+ * // Click button.+ * await window.click('text=Click me');+ * // Exit app.+ * await electronApp.close();+ * })();+ * ```+ *+ */+export interface ElectronApplication {+ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-option-expression).+ *+ * If the function passed to the+ * [electronApplication.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate)+ * returns a [Promise], then+ * [electronApplication.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate)+ * would wait for the promise to resolve and return its value.+ *+ * If the function passed to the+ * [electronApplication.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate)+ * returns a non-[Serializable] value, then+ * [electronApplication.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate)+ * returns `undefined`. Playwright also supports transferring some additional values that are not serializable by+ * `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.+ * @param pageFunction Function to be evaluated in the main Electron process.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-option-expression).+ */+ evaluate<R, Arg>(pageFunction: PageFunctionOn<ElectronType, Arg, R>, arg: Arg): Promise<R>;+ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-option-expression).+ *+ * If the function passed to the+ * [electronApplication.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate)+ * returns a [Promise], then+ * [electronApplication.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate)+ * would wait for the promise to resolve and return its value.+ *+ * If the function passed to the+ * [electronApplication.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate)+ * returns a non-[Serializable] value, then+ * [electronApplication.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate)+ * returns `undefined`. Playwright also supports transferring some additional values that are not serializable by+ * `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.+ * @param pageFunction Function to be evaluated in the main Electron process.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-option-expression).+ */+ evaluate<R>(pageFunction: PageFunctionOn<ElectronType, void, R>, arg?: any): Promise<R>;++ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-handle-option-expression)+ * as a [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * The only difference between+ * [electronApplication.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate)+ * and+ * [electronApplication.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-handle)+ * is that+ * [electronApplication.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-handle)+ * returns [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * If the function passed to the+ * [electronApplication.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-handle)+ * returns a [Promise], then+ * [electronApplication.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-handle)+ * would wait for the promise to resolve and return its value.+ * @param pageFunction Function to be evaluated in the main Electron process.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-handle-option-expression).+ */+ evaluateHandle<R, Arg>(pageFunction: PageFunctionOn<ElectronType, Arg, R>, arg: Arg): Promise<SmartHandle<R>>;+ /**+ * Returns the return value of+ * [`pageFunction`](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-handle-option-expression)+ * as a [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * The only difference between+ * [electronApplication.evaluate(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate)+ * and+ * [electronApplication.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-handle)+ * is that+ * [electronApplication.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-handle)+ * returns [JSHandle](https://playwright.dev/docs/api/class-jshandle).+ *+ * If the function passed to the+ * [electronApplication.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-handle)+ * returns a [Promise], then+ * [electronApplication.evaluateHandle(pageFunction[, arg])](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-handle)+ * would wait for the promise to resolve and return its value.+ * @param pageFunction Function to be evaluated in the main Electron process.+ * @param arg Optional argument to pass to+ * [`pageFunction`](https://playwright.dev/docs/api/class-electronapplication#electron-application-evaluate-handle-option-expression).+ */+ evaluateHandle<R>(pageFunction: PageFunctionOn<ElectronType, void, R>, arg?: any): Promise<SmartHandle<R>>;+ /**+ * This event is issued when the application process has been terminated.+ */+ on(event: 'close', listener: () => any): this;++ /**+ * Emitted when JavaScript within the Electron main process calls one of console API methods, e.g. `console.log` or+ * `console.dir`.+ *+ * The arguments passed into `console.log` are available on the+ * [ConsoleMessage](https://playwright.dev/docs/api/class-consolemessage) event handler argument.+ *+ * **Usage**+ *+ * ```js+ * electronApp.on('console', async msg => {+ * const values = [];+ * for (const arg of msg.args())+ * values.push(await arg.jsonValue());+ * console.log(...values);+ * });+ * await electronApp.evaluate(() => console.log('hello', 5, { foo: 'bar' }));+ * ```+ *+ */+ on(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * This event is issued for every window that is created **and loaded** in Electron. It contains a+ * [Page](https://playwright.dev/docs/api/class-page) that can be used for Playwright automation.+ */+ on(event: 'window', listener: (page: Page) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'close', listener: () => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'window', listener: (page: Page) => any): this;++ /**+ * This event is issued when the application process has been terminated.+ */+ addListener(event: 'close', listener: () => any): this;++ /**+ * Emitted when JavaScript within the Electron main process calls one of console API methods, e.g. `console.log` or+ * `console.dir`.+ *+ * The arguments passed into `console.log` are available on the+ * [ConsoleMessage](https://playwright.dev/docs/api/class-consolemessage) event handler argument.+ *+ * **Usage**+ *+ * ```js+ * electronApp.on('console', async msg => {+ * const values = [];+ * for (const arg of msg.args())+ * values.push(await arg.jsonValue());+ * console.log(...values);+ * });+ * await electronApp.evaluate(() => console.log('hello', 5, { foo: 'bar' }));+ * ```+ *+ */+ addListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * This event is issued for every window that is created **and loaded** in Electron. It contains a+ * [Page](https://playwright.dev/docs/api/class-page) that can be used for Playwright automation.+ */+ addListener(event: 'window', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'close', listener: () => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'window', listener: (page: Page) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'close', listener: () => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'window', listener: (page: Page) => any): this;++ /**+ * This event is issued when the application process has been terminated.+ */+ prependListener(event: 'close', listener: () => any): this;++ /**+ * Emitted when JavaScript within the Electron main process calls one of console API methods, e.g. `console.log` or+ * `console.dir`.+ *+ * The arguments passed into `console.log` are available on the+ * [ConsoleMessage](https://playwright.dev/docs/api/class-consolemessage) event handler argument.+ *+ * **Usage**+ *+ * ```js+ * electronApp.on('console', async msg => {+ * const values = [];+ * for (const arg of msg.args())+ * values.push(await arg.jsonValue());+ * console.log(...values);+ * });+ * await electronApp.evaluate(() => console.log('hello', 5, { foo: 'bar' }));+ * ```+ *+ */+ prependListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;++ /**+ * This event is issued for every window that is created **and loaded** in Electron. It contains a+ * [Page](https://playwright.dev/docs/api/class-page) that can be used for Playwright automation.+ */+ prependListener(event: 'window', listener: (page: Page) => any): this;++ /**+ * Returns the BrowserWindow object that corresponds to the given Playwright page.+ * @param page Page to retrieve the window for.+ */+ browserWindow(page: Page): Promise<JSHandle>;++ /**+ * Closes Electron application.+ */+ close(): Promise<void>;++ /**+ * This method returns browser context that can be used for setting up context-wide routing, etc.+ */+ context(): BrowserContext;++ /**+ * Convenience method that waits for the first application window to be opened.+ *+ * **Usage**+ *+ * ```js+ * const electronApp = await electron.launch({+ * args: ['main.js']+ * });+ * const window = await electronApp.firstWindow();+ * // ...+ * ```+ *+ * @param options+ */+ firstWindow(options?: {+ /**+ * Maximum time to wait for in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The+ * default value can be changed by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout).+ */+ timeout?: number;+ }): Promise<Page>;++ /**+ * Returns the main process for this Electron Application.+ */+ process(): ChildProcess;++ /**+ * This event is issued when the application process has been terminated.+ */+ waitForEvent(event: 'close', optionsOrPredicate?: { predicate?: () => boolean | Promise<boolean>, timeout?: number } | (() => boolean | Promise<boolean>)): Promise<void>;++ /**+ * Emitted when JavaScript within the Electron main process calls one of console API methods, e.g. `console.log` or+ * `console.dir`.+ *+ * The arguments passed into `console.log` are available on the+ * [ConsoleMessage](https://playwright.dev/docs/api/class-consolemessage) event handler argument.+ *+ * **Usage**+ *+ * ```js+ * electronApp.on('console', async msg => {+ * const values = [];+ * for (const arg of msg.args())+ * values.push(await arg.jsonValue());+ * console.log(...values);+ * });+ * await electronApp.evaluate(() => console.log('hello', 5, { foo: 'bar' }));+ * ```+ *+ */+ waitForEvent(event: 'console', optionsOrPredicate?: { predicate?: (consoleMessage: ConsoleMessage) => boolean | Promise<boolean>, timeout?: number } | ((consoleMessage: ConsoleMessage) => boolean | Promise<boolean>)): Promise<ConsoleMessage>;++ /**+ * This event is issued for every window that is created **and loaded** in Electron. It contains a+ * [Page](https://playwright.dev/docs/api/class-page) that can be used for Playwright automation.+ */+ waitForEvent(event: 'window', optionsOrPredicate?: { predicate?: (page: Page) => boolean | Promise<boolean>, timeout?: number } | ((page: Page) => boolean | Promise<boolean>)): Promise<Page>;+++ /**+ * Convenience method that returns all the opened windows.+ */+ windows(): Array<Page>;++ [Symbol.asyncDispose](): Promise<void>;+}++export type AndroidElementInfo = {+ clazz: string;+ desc: string;+ res: string;+ pkg: string;+ text: string;+ bounds: { x: number, y: number, width: number, height: number };+ checkable: boolean;+ checked: boolean;+ clickable: boolean;+ enabled: boolean;+ focusable: boolean;+ focused: boolean;+ longClickable: boolean;+ scrollable: boolean;+ selected: boolean;+};++export type AndroidSelector = {+ checkable?: boolean,+ checked?: boolean,+ clazz?: string | RegExp,+ clickable?: boolean,+ depth?: number,+ desc?: string | RegExp,+ enabled?: boolean,+ focusable?: boolean,+ focused?: boolean,+ hasChild?: { selector: AndroidSelector },+ hasDescendant?: { selector: AndroidSelector, maxDepth?: number },+ longClickable?: boolean,+ pkg?: string | RegExp,+ res?: string | RegExp,+ scrollable?: boolean,+ selected?: boolean,+ text?: string | RegExp,+};++export type AndroidKey =+ 'Unknown' |+ 'SoftLeft' | 'SoftRight' |+ 'Home' |+ 'Back' |+ 'Call' | 'EndCall' |+ '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' |+ 'Star' | 'Pound' | '*' | '#' |+ 'DialUp' | 'DialDown' | 'DialLeft' | 'DialRight' | 'DialCenter' |+ 'VolumeUp' | 'VolumeDown' |+ 'ChannelUp' | 'ChannelDown' |+ 'Power' |+ 'Camera' |+ 'Clear' |+ 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' |+ 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' |+ 'Comma' | ',' |+ 'Period' | '.' |+ 'AltLeft' | 'AltRight' |+ 'ShiftLeft' | 'ShiftRight' |+ 'Tab' | '\t' |+ 'Space' | ' ' |+ 'Sym' |+ 'Explorer' |+ 'Envelop' |+ 'Enter' | '\n' |+ 'Del' |+ 'Grave' |+ 'Minus' | '-' |+ 'Equals' | '=' |+ 'LeftBracket' | '(' |+ 'RightBracket' | ')' |+ 'Backslash' | '\\' |+ 'Semicolon' | ';' |+ 'Apostrophe' | '`' |+ 'Slash' | '/' |+ 'At' | '@' |+ 'Num' |+ 'HeadsetHook' |+ 'Focus' |+ 'Plus' | '+' |+ 'Menu' |+ 'Notification' |+ 'Search' |+ 'RecentApps' |+ 'AppSwitch' |+ 'Assist' |+ 'Cut' |+ 'Copy' |+ 'Paste';++export const _electron: Electron;+export const _android: Android;+export const _bidiChromium: BrowserType;+export const _bidiFirefox: BrowserType;++// This is required to not export everything by default. See https://github.com/Microsoft/TypeScript/issues/19545#issuecomment-340490459+export {};+++/**+ * Playwright has **experimental** support for Android automation. This includes Chrome for Android and Android+ * WebView.+ *+ * *Requirements*+ * - Android device or AVD Emulator.+ * - [ADB daemon](https://developer.android.com/studio/command-line/adb) running and authenticated with your device.+ * Typically running `adb devices` is all you need to do.+ * - [`Chrome 87`](https://play.google.com/store/apps/details?id=com.android.chrome) or newer installed on the+ * device+ * - "Enable command line on non-rooted devices" enabled in `chrome://flags`.+ *+ * *Known limitations*+ * - Raw USB operation is not yet supported, so you need ADB.+ * - Device needs to be awake to produce screenshots. Enabling "Stay awake" developer mode will help.+ * - We didn't run all the tests against the device, so not everything works.+ *+ * *How to run*+ *+ * An example of the Android automation script would be:+ *+ * ```js+ * const { _android: android } = require('playwright');+ *+ * (async () => {+ * // Connect to the device.+ * const [device] = await android.devices();+ * console.log(`Model: ${device.model()}`);+ * console.log(`Serial: ${device.serial()}`);+ * // Take screenshot of the whole device.+ * await device.screenshot({ path: 'device.png' });+ *+ * {+ * // --------------------- WebView -----------------------+ *+ * // Launch an application with WebView.+ * await device.shell('am force-stop org.chromium.webview_shell');+ * await device.shell('am start org.chromium.webview_shell/.WebViewBrowserActivity');+ * // Get the WebView.+ * const webview = await device.webView({ pkg: 'org.chromium.webview_shell' });+ *+ * // Fill the input box.+ * await device.fill({+ * res: 'org.chromium.webview_shell:id/url_field',+ * }, 'github.com/microsoft/playwright');+ * await device.press({+ * res: 'org.chromium.webview_shell:id/url_field',+ * }, 'Enter');+ *+ * // Work with WebView's page as usual.+ * const page = await webview.page();+ * await page.waitForNavigation({ url: /.*microsoft\/playwright.*\/ });+ * console.log(await page.title());+ * }+ *+ * {+ * // --------------------- Browser -----------------------+ *+ * // Launch Chrome browser.+ * await device.shell('am force-stop com.android.chrome');+ * const context = await device.launchBrowser();+ *+ * // Use BrowserContext as usual.+ * const page = await context.newPage();+ * await page.goto('https://webkit.org/');+ * console.log(await page.evaluate(() => window.location.href));+ * await page.screenshot({ path: 'page.png' });+ *+ * await context.close();+ * }+ *+ * // Close the device.+ * await device.close();+ * })();+ * ```+ *+ */+export interface Android {+ /**+ * This methods attaches Playwright to an existing Android device. Use+ * [android.launchServer([options])](https://playwright.dev/docs/api/class-android#android-launch-server) to launch a+ * new Android server instance.+ * @param wsEndpoint A browser websocket endpoint to connect to.+ * @param options+ */+ connect(wsEndpoint: string, options?: {+ /**+ * Additional HTTP headers to be sent with web socket connect request. Optional.+ */+ headers?: { [key: string]: string; };++ /**+ * Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going+ * on. Defaults to `0`.+ */+ slowMo?: number;++ /**+ * Maximum time in milliseconds to wait for the connection to be established. Defaults to `30000` (30 seconds). Pass+ * `0` to disable timeout.+ */+ timeout?: number;+ }): Promise<AndroidDevice>;++ /**+ * Returns the list of detected Android devices.+ * @param options+ */+ devices(options?: {+ /**+ * Optional host to establish ADB server connection. Default to `127.0.0.1`.+ */+ host?: string;++ /**+ * Prevents automatic playwright driver installation on attach. Assumes that the drivers have been installed already.+ */+ omitDriverInstall?: boolean;++ /**+ * Optional port to establish ADB server connection. Default to `5037`.+ */+ port?: number;+ }): Promise<Array<AndroidDevice>>;++ /**+ * Launches Playwright Android server that clients can connect to. See the following example:+ *+ * **Usage**+ *+ * Server Side:+ *+ * ```js+ * const { _android } = require('playwright');+ *+ * (async () => {+ * const browserServer = await _android.launchServer({+ * // If you have multiple devices connected and want to use a specific one.+ * // deviceSerialNumber: '<deviceSerialNumber>',+ * });+ * const wsEndpoint = browserServer.wsEndpoint();+ * console.log(wsEndpoint);+ * })();+ * ```+ *+ * Client Side:+ *+ * ```js+ * const { _android } = require('playwright');+ *+ * (async () => {+ * const device = await _android.connect('<wsEndpoint>');+ *+ * console.log(device.model());+ * console.log(device.serial());+ * await device.shell('am force-stop com.android.chrome');+ * const context = await device.launchBrowser();+ *+ * const page = await context.newPage();+ * await page.goto('https://webkit.org/');+ * console.log(await page.evaluate(() => window.location.href));+ * await page.screenshot({ path: 'page-chrome-1.png' });+ *+ * await context.close();+ * })();+ * ```+ *+ * @param options+ */+ launchServer(options?: {+ /**+ * Optional host to establish ADB server connection. Default to `127.0.0.1`.+ */+ adbHost?: string;++ /**+ * Optional port to establish ADB server connection. Default to `5037`.+ */+ adbPort?: number;++ /**+ * Optional device serial number to launch the browser on. If not specified, it will throw if multiple devices are+ * connected.+ */+ deviceSerialNumber?: string;++ /**+ * Host to use for the web socket. It is optional and if it is omitted, the server will accept connections on the+ * unspecified IPv6 address (::) when IPv6 is available, or the unspecified IPv4 address (0.0.0.0) otherwise. Consider+ * hardening it with picking a specific interface.+ */+ host?: string;++ /**+ * Prevents automatic playwright driver installation on attach. Assumes that the drivers have been installed already.+ */+ omitDriverInstall?: boolean;++ /**+ * Port to use for the web socket. Defaults to 0 that picks any available port.+ */+ port?: number;++ /**+ * Path at which to serve the Android Server. For security, this defaults to an unguessable string.+ *+ * **NOTE** Any process or web page (including those running in Playwright) with knowledge of the `wsPath` can take+ * control of the OS user. For this reason, you should use an unguessable token when using this option.+ *+ */+ wsPath?: string;+ }): Promise<BrowserServer>;++ /**+ * This setting will change the default maximum time for all the methods accepting+ * [`timeout`](https://playwright.dev/docs/api/class-android#android-set-default-timeout-option-timeout) option.+ * @param timeout Maximum time in milliseconds+ */+ setDefaultTimeout(timeout: number): void;+}++/**+ * [AndroidDevice](https://playwright.dev/docs/api/class-androiddevice) represents a connected device, either real+ * hardware or emulated. Devices can be obtained using+ * [android.devices([options])](https://playwright.dev/docs/api/class-android#android-devices).+ */+export interface AndroidDevice {+ /**+ * Emitted when the device connection gets closed.+ */+ on(event: 'close', listener: (androidDevice: AndroidDevice) => any): this;++ /**+ * Emitted when a new WebView instance is detected.+ */+ on(event: 'webview', listener: (androidWebView: AndroidWebView) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'close', listener: (androidDevice: AndroidDevice) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'webview', listener: (androidWebView: AndroidWebView) => any): this;++ /**+ * Emitted when the device connection gets closed.+ */+ addListener(event: 'close', listener: (androidDevice: AndroidDevice) => any): this;++ /**+ * Emitted when a new WebView instance is detected.+ */+ addListener(event: 'webview', listener: (androidWebView: AndroidWebView) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'close', listener: (androidDevice: AndroidDevice) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'webview', listener: (androidWebView: AndroidWebView) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'close', listener: (androidDevice: AndroidDevice) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'webview', listener: (androidWebView: AndroidWebView) => any): this;++ /**+ * Emitted when the device connection gets closed.+ */+ prependListener(event: 'close', listener: (androidDevice: AndroidDevice) => any): this;++ /**+ * Emitted when a new WebView instance is detected.+ */+ prependListener(event: 'webview', listener: (androidWebView: AndroidWebView) => any): this;++ /**+ * Disconnects from the device.+ */+ close(): Promise<void>;++ /**+ * Drags the widget defined by+ * [`selector`](https://playwright.dev/docs/api/class-androiddevice#android-device-drag-option-selector) towards+ * [`dest`](https://playwright.dev/docs/api/class-androiddevice#android-device-drag-option-dest) point.+ * @param selector Selector to drag.+ * @param dest Point to drag to.+ * @param options+ */+ drag(selector: AndroidSelector, dest: {+ x: number;++ y: number;+ }, options?: {+ /**+ * Optional speed of the drag in pixels per second.+ */+ speed?: number;++ /**+ * Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed+ * by using the+ * [androidDevice.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-androiddevice#android-device-set-default-timeout)+ * method.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Fills the specific+ * [`selector`](https://playwright.dev/docs/api/class-androiddevice#android-device-fill-option-selector) input box+ * with [`text`](https://playwright.dev/docs/api/class-androiddevice#android-device-fill-option-text).+ * @param selector Selector to fill.+ * @param text Text to be filled in the input box.+ * @param options+ */+ fill(selector: AndroidSelector, text: string, options?: {+ /**+ * Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed+ * by using the+ * [androidDevice.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-androiddevice#android-device-set-default-timeout)+ * method.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Flings the widget defined by+ * [`selector`](https://playwright.dev/docs/api/class-androiddevice#android-device-fling-option-selector) in the+ * specified [`direction`](https://playwright.dev/docs/api/class-androiddevice#android-device-fling-option-direction).+ * @param selector Selector to fling.+ * @param direction Fling direction.+ * @param options+ */+ fling(selector: AndroidSelector, direction: "down"|"up"|"left"|"right", options?: {+ /**+ * Optional speed of the fling in pixels per second.+ */+ speed?: number;++ /**+ * Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed+ * by using the+ * [androidDevice.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-androiddevice#android-device-set-default-timeout)+ * method.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Returns information about a widget defined by+ * [`selector`](https://playwright.dev/docs/api/class-androiddevice#android-device-info-option-selector).+ * @param selector Selector to return information about.+ */+ info(selector: AndroidSelector): Promise<AndroidElementInfo>;++ /**+ * Installs an apk on the device.+ * @param file Either a path to the apk file, or apk file content.+ * @param options+ */+ installApk(file: string|Buffer, options?: {+ /**+ * Optional arguments to pass to the `shell:cmd package install` call. Defaults to `-r -t -S`.+ */+ args?: Array<string>;+ }): Promise<void>;++ /**+ * Launches Chrome browser on the device, and returns its persistent context.+ * @param options+ */+ launchBrowser(options?: {+ /**+ * Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.+ */+ acceptDownloads?: boolean;++ /**+ * An object containing an option to throw an error when API request returns status codes other than 2xx and 3xx. By+ * default, response object is returned for all status codes.+ */+ apiRequestFailsOnErrorStatus?: boolean;++ /**+ * **NOTE** Use custom browser args at your own risk, as some of them may break Playwright functionality.+ *+ * Additional arguments to pass to the browser instance. The list of Chromium flags can be found+ * [here](https://peter.sh/experiments/chromium-command-line-switches/).+ */+ args?: Array<string>;++ /**+ * When using [page.goto(url[, options])](https://playwright.dev/docs/api/class-page#page-goto),+ * [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route),+ * [page.waitForURL(url[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-url),+ * [page.waitForRequest(urlOrPredicate[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-request),+ * or+ * [page.waitForResponse(urlOrPredicate[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-response)+ * it takes the base URL in consideration by using the+ * [`URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor for building the corresponding URL.+ * Unset by default. Examples:+ * - baseURL: `http://localhost:3000` and navigating to `/bar.html` results in `http://localhost:3000/bar.html`+ * - baseURL: `http://localhost:3000/foo/` and navigating to `./bar.html` results in+ * `http://localhost:3000/foo/bar.html`+ * - baseURL: `http://localhost:3000/foo` (without trailing slash) and navigating to `./bar.html` results in+ * `http://localhost:3000/bar.html`+ */+ baseURL?: string;++ /**+ * Toggles bypassing page's Content-Security-Policy. Defaults to `false`.+ */+ bypassCSP?: boolean;++ /**+ * Emulates [prefers-colors-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)+ * media feature, supported values are `'light'` and `'dark'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'light'`.+ */+ colorScheme?: null|"light"|"dark"|"no-preference";++ /**+ * Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'no-preference'`.+ */+ contrast?: null|"no-preference"|"more";++ /**+ * Specify device scale factor (can be thought of as dpr). Defaults to `1`. Learn more about+ * [emulating devices with device scale factor](https://playwright.dev/docs/emulation#devices).+ */+ deviceScaleFactor?: number;++ /**+ * An object containing additional HTTP headers to be sent with every request. Defaults to none.+ */+ extraHTTPHeaders?: { [key: string]: string; };++ /**+ * Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'none'`.+ */+ forcedColors?: null|"active"|"none";++ geolocation?: {+ /**+ * Latitude between -90 and 90.+ */+ latitude: number;++ /**+ * Longitude between -180 and 180.+ */+ longitude: number;++ /**+ * Non-negative accuracy value. Defaults to `0`.+ */+ accuracy?: number;+ };++ /**+ * Specifies if viewport supports touch events. Defaults to false. Learn more about+ * [mobile emulation](https://playwright.dev/docs/emulation#devices).+ */+ hasTouch?: boolean;++ /**+ * Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If no+ * origin is specified, the username and password are sent to any servers upon unauthorized responses.+ */+ httpCredentials?: {+ username: string;++ password: string;++ /**+ * Restrain sending http credentials on specific origin (scheme://host:port).+ */+ origin?: string;++ /**+ * This option only applies to the requests sent from corresponding+ * [APIRequestContext](https://playwright.dev/docs/api/class-apirequestcontext) and does not affect requests sent from+ * the browser. `'always'` - `Authorization` header with basic authentication credentials will be sent with the each+ * API request. `'unauthorized` - the credentials are only sent when 401 (Unauthorized) response with+ * `WWW-Authenticate` header is received. Defaults to `'unauthorized'`.+ */+ send?: "unauthorized"|"always";+ };++ /**+ * Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.+ */+ ignoreHTTPSErrors?: boolean;++ /**+ * Whether the `meta viewport` tag is taken into account and touch events are enabled. isMobile is a part of device,+ * so you don't actually need to set it manually. Defaults to `false` and is not supported in Firefox. Learn more+ * about [mobile emulation](https://playwright.dev/docs/emulation#ismobile).+ */+ isMobile?: boolean;++ /**+ * Whether or not to enable JavaScript in the context. Defaults to `true`. Learn more about+ * [disabling JavaScript](https://playwright.dev/docs/emulation#javascript-enabled).+ */+ javaScriptEnabled?: boolean;++ /**+ * Specify user locale, for example `en-GB`, `de-DE`, etc. Locale will affect `navigator.language` value,+ * `Accept-Language` request header value as well as number and date formatting rules. Defaults to the system default+ * locale. Learn more about emulation in our [emulation guide](https://playwright.dev/docs/emulation#locale--timezone).+ */+ locale?: string;++ /**+ * Logger sink for Playwright logging.+ */+ logger?: Logger;++ /**+ * Whether to emulate network being offline. Defaults to `false`. Learn more about+ * [network emulation](https://playwright.dev/docs/emulation#offline).+ */+ offline?: boolean;++ /**+ * A list of permissions to grant to all pages in this context. See+ * [browserContext.grantPermissions(permissions[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-grant-permissions)+ * for more details. Defaults to none.+ */+ permissions?: Array<string>;++ /**+ * Optional package name to launch instead of default Chrome for Android.+ */+ pkg?: string;++ /**+ * Network proxy settings.+ */+ proxy?: {+ /**+ * Proxy to be used for all requests. HTTP and SOCKS proxies are supported, for example `http://myproxy.com:3128` or+ * `socks5://myproxy.com:3128`. Short form `myproxy.com:3128` is considered an HTTP proxy.+ */+ server: string;++ /**+ * Optional comma-separated domains to bypass proxy, for example `".com, chromium.org, .domain.com"`.+ */+ bypass?: string;++ /**+ * Optional username to use if HTTP proxy requires authentication.+ */+ username?: string;++ /**+ * Optional password to use if HTTP proxy requires authentication.+ */+ password?: string;+ };++ /**+ * Enables [HAR](http://www.softwareishard.com/blog/har-12-spec) recording for all pages into `recordHar.path` file.+ * If not specified, the HAR is not recorded. Make sure to await+ * [browserContext.close([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-close) for+ * the HAR to be saved.+ */+ recordHar?: {+ /**+ * Optional setting to control whether to omit request content from the HAR. Defaults to `false`. Deprecated, use+ * `content` policy instead.+ */+ omitContent?: boolean;++ /**+ * Optional setting to control resource content management. If `omit` is specified, content is not persisted. If+ * `attach` is specified, resources are persisted as separate files or entries in the ZIP archive. If `embed` is+ * specified, content is stored inline the HAR file as per HAR specification. Defaults to `attach` for `.zip` output+ * files and to `embed` for all other file extensions.+ */+ content?: "omit"|"embed"|"attach";++ /**+ * Path on the filesystem to write the HAR file to. If the file name ends with `.zip`, `content: 'attach'` is used by+ * default.+ */+ path: string;++ /**+ * When set to `minimal`, only record information necessary for routing from HAR. This omits sizes, timing, page,+ * cookies, security and other types of HAR information that are not used when replaying from HAR. Defaults to `full`.+ */+ mode?: "full"|"minimal";++ /**+ * A glob or regex pattern to filter requests that are stored in the HAR. When a+ * [`baseURL`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-base-url) via the context+ * options was provided and the passed URL is a path, it gets merged via the+ * [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor. Defaults to none.+ */+ urlFilter?: string|RegExp;+ };++ /**+ * Enables video recording for all pages into `recordVideo.dir` directory. If not specified videos are not recorded.+ * Make sure to await+ * [browserContext.close([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-close) for+ * videos to be saved.+ */+ recordVideo?: {+ /**+ * Path to the directory to put videos into.+ */+ dir: string;++ /**+ * Optional dimensions of the recorded videos. If not specified the size will be equal to `viewport` scaled down to+ * fit into 800x800. If `viewport` is not configured explicitly the video size defaults to 800x450. Actual picture of+ * each page will be scaled down if necessary to fit the specified size.+ */+ size?: {+ /**+ * Video frame width.+ */+ width: number;++ /**+ * Video frame height.+ */+ height: number;+ };+ };++ /**+ * Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'no-preference'`.+ */+ reducedMotion?: null|"reduce"|"no-preference";++ /**+ * Emulates consistent window screen size available inside web page via `window.screen`. Is only used when the+ * [`viewport`](https://playwright.dev/docs/api/class-androiddevice#android-device-launch-browser-option-viewport) is+ * set.+ */+ screen?: {+ /**+ * page width in pixels.+ */+ width: number;++ /**+ * page height in pixels.+ */+ height: number;+ };++ /**+ * Whether to allow sites to register Service workers. Defaults to `'allow'`.+ * - `'allow'`: [Service Workers](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) can be+ * registered.+ * - `'block'`: Playwright will block all registration of Service Workers.+ */+ serviceWorkers?: "allow"|"block";++ /**+ * If set to true, enables strict selectors mode for this context. In the strict selectors mode all operations on+ * selectors that imply single target DOM element will throw when more than one element matches the selector. This+ * option does not affect any Locator APIs (Locators are always strict). Defaults to `false`. See+ * [Locator](https://playwright.dev/docs/api/class-locator) to learn more about the strict mode.+ */+ strictSelectors?: boolean;++ /**+ * Changes the timezone of the context. See+ * [ICU's metaZones.txt](https://cs.chromium.org/chromium/src/third_party/icu/source/data/misc/metaZones.txt?rcl=faee8bc70570192d82d2978a71e2a615788597d1)+ * for a list of supported timezone IDs. Defaults to the system timezone.+ */+ timezoneId?: string;++ /**+ * Specific user agent to use in this context.+ */+ userAgent?: string;++ /**+ * @deprecated Use+ * [`recordVideo`](https://playwright.dev/docs/api/class-androiddevice#android-device-launch-browser-option-record-video)+ * instead.+ */+ videoSize?: {+ /**+ * Video frame width.+ */+ width: number;++ /**+ * Video frame height.+ */+ height: number;+ };++ /**+ * @deprecated Use+ * [`recordVideo`](https://playwright.dev/docs/api/class-androiddevice#android-device-launch-browser-option-record-video)+ * instead.+ */+ videosPath?: string;++ /**+ * Emulates consistent viewport for each page. Defaults to an 1280x720 viewport. Use `null` to disable the consistent+ * viewport emulation. Learn more about [viewport emulation](https://playwright.dev/docs/emulation#viewport).+ *+ * **NOTE** The `null` value opts out from the default presets, makes viewport depend on the host window size defined+ * by the operating system. It makes the execution of the tests non-deterministic.+ *+ */+ viewport?: null|{+ /**+ * page width in pixels.+ */+ width: number;++ /**+ * page height in pixels.+ */+ height: number;+ };+ }): Promise<BrowserContext>;++ /**+ * Performs a long tap on the widget defined by+ * [`selector`](https://playwright.dev/docs/api/class-androiddevice#android-device-long-tap-option-selector).+ * @param selector Selector to tap on.+ * @param options+ */+ longTap(selector: AndroidSelector, options?: {+ /**+ * Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed+ * by using the+ * [androidDevice.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-androiddevice#android-device-set-default-timeout)+ * method.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Device model.+ */+ model(): string;++ /**+ * Launches a process in the shell on the device and returns a socket to communicate with the launched process.+ * @param command Shell command to execute.+ */+ open(command: string): Promise<AndroidSocket>;++ /**+ * Pinches the widget defined by+ * [`selector`](https://playwright.dev/docs/api/class-androiddevice#android-device-pinch-close-option-selector) in the+ * closing direction.+ * @param selector Selector to pinch close.+ * @param percent The size of the pinch as a percentage of the widget's size.+ * @param options+ */+ pinchClose(selector: AndroidSelector, percent: number, options?: {+ /**+ * Optional speed of the pinch in pixels per second.+ */+ speed?: number;++ /**+ * Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed+ * by using the+ * [androidDevice.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-androiddevice#android-device-set-default-timeout)+ * method.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Pinches the widget defined by+ * [`selector`](https://playwright.dev/docs/api/class-androiddevice#android-device-pinch-open-option-selector) in the+ * open direction.+ * @param selector Selector to pinch open.+ * @param percent The size of the pinch as a percentage of the widget's size.+ * @param options+ */+ pinchOpen(selector: AndroidSelector, percent: number, options?: {+ /**+ * Optional speed of the pinch in pixels per second.+ */+ speed?: number;++ /**+ * Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed+ * by using the+ * [androidDevice.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-androiddevice#android-device-set-default-timeout)+ * method.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Presses the specific [`key`](https://playwright.dev/docs/api/class-androiddevice#android-device-press-option-key)+ * in the widget defined by+ * [`selector`](https://playwright.dev/docs/api/class-androiddevice#android-device-press-option-selector).+ * @param selector Selector to press the key in.+ * @param key The key to press.+ * @param options+ */+ press(selector: AndroidSelector, key: AndroidKey, options?: {+ /**+ * Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed+ * by using the+ * [androidDevice.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-androiddevice#android-device-set-default-timeout)+ * method.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Copies a file to the device.+ * @param file Either a path to the file, or file content.+ * @param path Path to the file on the device.+ * @param options+ */+ push(file: string|Buffer, path: string, options?: {+ /**+ * Optional file mode, defaults to `644` (`rw-r--r--`).+ */+ mode?: number;+ }): Promise<void>;++ /**+ * Returns the buffer with the captured screenshot of the device.+ * @param options+ */+ screenshot(options?: {+ /**+ * The file path to save the image to. If+ * [`path`](https://playwright.dev/docs/api/class-androiddevice#android-device-screenshot-option-path) is a relative+ * path, then it is resolved relative to the current working directory. If no path is provided, the image won't be+ * saved to the disk.+ */+ path?: string;+ }): Promise<Buffer>;++ /**+ * Scrolls the widget defined by+ * [`selector`](https://playwright.dev/docs/api/class-androiddevice#android-device-scroll-option-selector) in the+ * specified+ * [`direction`](https://playwright.dev/docs/api/class-androiddevice#android-device-scroll-option-direction).+ * @param selector Selector to scroll.+ * @param direction Scroll direction.+ * @param percent Distance to scroll as a percentage of the widget's size.+ * @param options+ */+ scroll(selector: AndroidSelector, direction: "down"|"up"|"left"|"right", percent: number, options?: {+ /**+ * Optional speed of the scroll in pixels per second.+ */+ speed?: number;++ /**+ * Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed+ * by using the+ * [androidDevice.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-androiddevice#android-device-set-default-timeout)+ * method.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Device serial number.+ */+ serial(): string;++ /**+ * This setting will change the default maximum time for all the methods accepting+ * [`timeout`](https://playwright.dev/docs/api/class-androiddevice#android-device-set-default-timeout-option-timeout)+ * option.+ * @param timeout Maximum time in milliseconds+ */+ setDefaultTimeout(timeout: number): void;++ /**+ * Executes a shell command on the device and returns its output.+ * @param command Shell command to execute.+ */+ shell(command: string): Promise<Buffer>;++ /**+ * Swipes the widget defined by+ * [`selector`](https://playwright.dev/docs/api/class-androiddevice#android-device-swipe-option-selector) in the+ * specified [`direction`](https://playwright.dev/docs/api/class-androiddevice#android-device-swipe-option-direction).+ * @param selector Selector to swipe.+ * @param direction Swipe direction.+ * @param percent Distance to swipe as a percentage of the widget's size.+ * @param options+ */+ swipe(selector: AndroidSelector, direction: "down"|"up"|"left"|"right", percent: number, options?: {+ /**+ * Optional speed of the swipe in pixels per second.+ */+ speed?: number;++ /**+ * Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed+ * by using the+ * [androidDevice.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-androiddevice#android-device-set-default-timeout)+ * method.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Taps on the widget defined by+ * [`selector`](https://playwright.dev/docs/api/class-androiddevice#android-device-tap-option-selector).+ * @param selector Selector to tap on.+ * @param options+ */+ tap(selector: AndroidSelector, options?: {+ /**+ * Optional duration of the tap in milliseconds.+ */+ duration?: number;++ /**+ * Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed+ * by using the+ * [androidDevice.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-androiddevice#android-device-set-default-timeout)+ * method.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Waits for the specific+ * [`selector`](https://playwright.dev/docs/api/class-androiddevice#android-device-wait-option-selector) to either+ * appear or disappear, depending on the+ * [`state`](https://playwright.dev/docs/api/class-androiddevice#android-device-wait-option-state).+ * @param selector Selector to wait for.+ * @param options+ */+ wait(selector: AndroidSelector, options?: {+ /**+ * Optional state. Can be either:+ * - default - wait for element to be present.+ * - `'gone'` - wait for element to not be present.+ */+ state?: "gone";++ /**+ * Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed+ * by using the+ * [androidDevice.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-androiddevice#android-device-set-default-timeout)+ * method.+ */+ timeout?: number;+ }): Promise<void>;++ /**+ * Emitted when the device connection gets closed.+ */+ waitForEvent(event: 'close', optionsOrPredicate?: { predicate?: (androidDevice: AndroidDevice) => boolean | Promise<boolean>, timeout?: number } | ((androidDevice: AndroidDevice) => boolean | Promise<boolean>)): Promise<AndroidDevice>;++ /**+ * Emitted when a new WebView instance is detected.+ */+ waitForEvent(event: 'webview', optionsOrPredicate?: { predicate?: (androidWebView: AndroidWebView) => boolean | Promise<boolean>, timeout?: number } | ((androidWebView: AndroidWebView) => boolean | Promise<boolean>)): Promise<AndroidWebView>;+++ /**+ * This method waits until [AndroidWebView](https://playwright.dev/docs/api/class-androidwebview) matching the+ * [`selector`](https://playwright.dev/docs/api/class-androiddevice#android-device-web-view-option-selector) is opened+ * and returns it. If there is already an open [AndroidWebView](https://playwright.dev/docs/api/class-androidwebview)+ * matching the+ * [`selector`](https://playwright.dev/docs/api/class-androiddevice#android-device-web-view-option-selector), returns+ * immediately.+ * @param selector+ * @param options+ */+ webView(selector: {+ /**+ * Optional Package identifier.+ */+ pkg?: string;++ /**+ * Optional webview socket name.+ */+ socketName?: string;+ }, options?: {+ /**+ * Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed+ * by using the+ * [androidDevice.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-androiddevice#android-device-set-default-timeout)+ * method.+ */+ timeout?: number;+ }): Promise<AndroidWebView>;++ /**+ * Currently open WebViews.+ */+ webViews(): Array<AndroidWebView>;++ input: AndroidInput;++ [Symbol.asyncDispose](): Promise<void>;+}++export interface AndroidInput {+ /**+ * Performs a drag between [`from`](https://playwright.dev/docs/api/class-androidinput#android-input-drag-option-from)+ * and [`to`](https://playwright.dev/docs/api/class-androidinput#android-input-drag-option-to) points.+ * @param from The start point of the drag.+ * @param to The end point of the drag.+ * @param steps The number of steps in the drag. Each step takes 5 milliseconds to complete.+ */+ drag(from: {+ x: number;++ y: number;+ }, to: {+ x: number;++ y: number;+ }, steps: number): Promise<void>;++ /**+ * Presses the [`key`](https://playwright.dev/docs/api/class-androidinput#android-input-press-option-key).+ * @param key Key to press.+ */+ press(key: AndroidKey): Promise<void>;++ /**+ * Swipes following the path defined by+ * [`segments`](https://playwright.dev/docs/api/class-androidinput#android-input-swipe-option-segments).+ * @param from The point to start swiping from.+ * @param segments Points following the [`from`](https://playwright.dev/docs/api/class-androidinput#android-input-swipe-option-from)+ * point in the swipe gesture.+ * @param steps The number of steps for each segment. Each step takes 5 milliseconds to complete, so 100 steps means half a second+ * per each segment.+ */+ swipe(from: {+ x: number;++ y: number;+ }, segments: ReadonlyArray<{+ x: number;++ y: number;+ }>, steps: number): Promise<void>;++ /**+ * Taps at the specified [`point`](https://playwright.dev/docs/api/class-androidinput#android-input-tap-option-point).+ * @param point The point to tap at.+ */+ tap(point: {+ x: number;++ y: number;+ }): Promise<void>;++ /**+ * Types [`text`](https://playwright.dev/docs/api/class-androidinput#android-input-type-option-text) into currently+ * focused widget.+ * @param text Text to type.+ */+ type(text: string): Promise<void>;+}++/**+ * [AndroidSocket](https://playwright.dev/docs/api/class-androidsocket) is a way to communicate with a process+ * launched on the [AndroidDevice](https://playwright.dev/docs/api/class-androiddevice). Use+ * [androidDevice.open(command)](https://playwright.dev/docs/api/class-androiddevice#android-device-open) to open a+ * socket.+ */+export interface AndroidSocket {+ /**+ * Emitted when the socket is closed.+ */+ on(event: 'close', listener: () => any): this;++ /**+ * Emitted when data is available to read from the socket.+ */+ on(event: 'data', listener: (buffer: Buffer) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'close', listener: () => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'data', listener: (buffer: Buffer) => any): this;++ /**+ * Emitted when the socket is closed.+ */+ addListener(event: 'close', listener: () => any): this;++ /**+ * Emitted when data is available to read from the socket.+ */+ addListener(event: 'data', listener: (buffer: Buffer) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'close', listener: () => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'data', listener: (buffer: Buffer) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'close', listener: () => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'data', listener: (buffer: Buffer) => any): this;++ /**+ * Emitted when the socket is closed.+ */+ prependListener(event: 'close', listener: () => any): this;++ /**+ * Emitted when data is available to read from the socket.+ */+ prependListener(event: 'data', listener: (buffer: Buffer) => any): this;++ /**+ * Closes the socket.+ */+ close(): Promise<void>;++ /**+ * Writes some [`data`](https://playwright.dev/docs/api/class-androidsocket#android-socket-write-option-data) to the+ * socket.+ * @param data Data to write.+ */+ write(data: Buffer): Promise<void>;++ [Symbol.asyncDispose](): Promise<void>;+}++/**+ * [AndroidWebView](https://playwright.dev/docs/api/class-androidwebview) represents a WebView open on the+ * [AndroidDevice](https://playwright.dev/docs/api/class-androiddevice). WebView is usually obtained using+ * [androidDevice.webView(selector[, options])](https://playwright.dev/docs/api/class-androiddevice#android-device-web-view).+ */+export interface AndroidWebView {+ /**+ * Emitted when the WebView is closed.+ */+ on(event: 'close', listener: () => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'close', listener: () => any): this;++ /**+ * Emitted when the WebView is closed.+ */+ addListener(event: 'close', listener: () => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'close', listener: () => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'close', listener: () => any): this;++ /**+ * Emitted when the WebView is closed.+ */+ prependListener(event: 'close', listener: () => any): this;++ /**+ * Connects to the WebView and returns a regular Playwright [Page](https://playwright.dev/docs/api/class-page) to+ * interact with.+ */+ page(): Promise<Page>;++ /**+ * WebView process PID.+ */+ pid(): number;++ /**+ * WebView package identifier.+ */+ pkg(): string;+}++/**+ * Exposes API that can be used for the Web API testing. This class is used for creating+ * [APIRequestContext](https://playwright.dev/docs/api/class-apirequestcontext) instance which in turn can be used for+ * sending web requests. An instance of this class can be obtained via+ * [playwright.request](https://playwright.dev/docs/api/class-playwright#playwright-request). For more information see+ * [APIRequestContext](https://playwright.dev/docs/api/class-apirequestcontext).+ */+export interface APIRequest {+ /**+ * Creates new instances of [APIRequestContext](https://playwright.dev/docs/api/class-apirequestcontext).+ * @param options+ */+ newContext(options?: {+ /**+ * An object containing an option to throw an error when API request returns status codes other than 2xx and 3xx. By+ * default, response object is returned for all status codes.+ */+ apiRequestFailsOnErrorStatus?: boolean;++ /**+ * Methods like+ * [apiRequestContext.get(url[, options])](https://playwright.dev/docs/api/class-apirequestcontext#api-request-context-get)+ * take the base URL into consideration by using the+ * [`URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor for building the corresponding URL.+ * Examples:+ * - baseURL: `http://localhost:3000` and sending request to `/bar.html` results in `http://localhost:3000/bar.html`+ * - baseURL: `http://localhost:3000/foo/` and sending request to `./bar.html` results in+ * `http://localhost:3000/foo/bar.html`+ * - baseURL: `http://localhost:3000/foo` (without trailing slash) and navigating to `./bar.html` results in+ * `http://localhost:3000/bar.html`+ */+ baseURL?: string;++ /**+ * TLS Client Authentication allows the server to request a client certificate and verify it.+ *+ * **Details**+ *+ * An array of client certificates to be used. Each certificate object must have either both `certPath` and `keyPath`,+ * a single `pfxPath`, or their corresponding direct value equivalents (`cert` and `key`, or `pfx`). Optionally,+ * `passphrase` property should be provided if the certificate is encrypted. The `origin` property should be provided+ * with an exact match to the request origin that the certificate is valid for.+ *+ * **NOTE** When using WebKit on macOS, accessing `localhost` will not pick up client certificates. You can make it+ * work by replacing `localhost` with `local.playwright`.+ *+ */+ clientCertificates?: Array<{+ /**+ * Exact origin that the certificate is valid for. Origin includes `https` protocol, a hostname and optionally a port.+ */+ origin: string;++ /**+ * Path to the file with the certificate in PEM format.+ */+ certPath?: string;++ /**+ * Direct value of the certificate in PEM format.+ */+ cert?: Buffer;++ /**+ * Path to the file with the private key in PEM format.+ */+ keyPath?: string;++ /**+ * Direct value of the private key in PEM format.+ */+ key?: Buffer;++ /**+ * Path to the PFX or PKCS12 encoded private key and certificate chain.+ */+ pfxPath?: string;++ /**+ * Direct value of the PFX or PKCS12 encoded private key and certificate chain.+ */+ pfx?: Buffer;++ /**+ * Passphrase for the private key (PEM or PFX).+ */+ passphrase?: string;+ }>;++ /**+ * An object containing additional HTTP headers to be sent with every request. Defaults to none.+ */+ extraHTTPHeaders?: { [key: string]: string; };++ /**+ * Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If no+ * origin is specified, the username and password are sent to any servers upon unauthorized responses.+ */+ httpCredentials?: {+ username: string;++ password: string;++ /**+ * Restrain sending http credentials on specific origin (scheme://host:port).+ */+ origin?: string;++ /**+ * This option only applies to the requests sent from corresponding+ * [APIRequestContext](https://playwright.dev/docs/api/class-apirequestcontext) and does not affect requests sent from+ * the browser. `'always'` - `Authorization` header with basic authentication credentials will be sent with the each+ * API request. `'unauthorized` - the credentials are only sent when 401 (Unauthorized) response with+ * `WWW-Authenticate` header is received. Defaults to `'unauthorized'`.+ */+ send?: "unauthorized"|"always";+ };++ /**+ * Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.+ */+ ignoreHTTPSErrors?: boolean;++ /**+ * Network proxy settings.+ */+ proxy?: {+ /**+ * Proxy to be used for all requests. HTTP and SOCKS proxies are supported, for example `http://myproxy.com:3128` or+ * `socks5://myproxy.com:3128`. Short form `myproxy.com:3128` is considered an HTTP proxy.+ */+ server: string;++ /**+ * Optional comma-separated domains to bypass proxy, for example `".com, chromium.org, .domain.com"`.+ */+ bypass?: string;++ /**+ * Optional username to use if HTTP proxy requires authentication.+ */+ username?: string;++ /**+ * Optional password to use if HTTP proxy requires authentication.+ */+ password?: string;+ };++ /**+ * Populates context with given storage state. This option can be used to initialize context with logged-in+ * information obtained via+ * [browserContext.storageState([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-storage-state)+ * or+ * [apiRequestContext.storageState([options])](https://playwright.dev/docs/api/class-apirequestcontext#api-request-context-storage-state).+ * Either a path to the file with saved storage, or the value returned by one of+ * [browserContext.storageState([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-storage-state)+ * or+ * [apiRequestContext.storageState([options])](https://playwright.dev/docs/api/class-apirequestcontext#api-request-context-storage-state)+ * methods.+ */+ storageState?: string|{+ cookies: Array<{+ name: string;++ value: string;++ domain: string;++ path: string;++ /**+ * Unix time in seconds.+ */+ expires: number;++ httpOnly: boolean;++ secure: boolean;++ sameSite: "Strict"|"Lax"|"None";+ }>;++ origins: Array<{+ origin: string;++ localStorage: Array<{+ name: string;++ value: string;+ }>;++ /**+ * indexedDB to set for context+ */+ indexedDB?: Array<{+ /**+ * database name+ */+ name: string;++ /**+ * database version+ */+ version: number;++ stores: Array<{+ name: string;++ keyPath?: string;++ keyPathArray?: Array<string>;++ autoIncrement: boolean;++ indexes: Array<{+ name: string;++ keyPath?: string;++ keyPathArray?: Array<string>;++ unique: boolean;++ multiEntry: boolean;+ }>;++ records: Array<{+ key?: Object;++ /**+ * if `key` is not JSON-serializable, this contains an encoded version that preserves types.+ */+ keyEncoded?: Object;++ value?: Object;++ /**+ * if `value` is not JSON-serializable, this contains an encoded version that preserves types.+ */+ valueEncoded?: Object;+ }>;+ }>;+ }>;+ }>;+ };++ /**+ * Maximum time in milliseconds to wait for the response. Defaults to `30000` (30 seconds). Pass `0` to disable+ * timeout.+ */+ timeout?: number;++ /**+ * Specific user agent to use in this context.+ */+ userAgent?: string;+ }): Promise<APIRequestContext>;+}++/**+ * This API is used for the Web API testing. You can use it to trigger API endpoints, configure micro-services,+ * prepare environment or the service to your e2e test.+ *+ * Each Playwright browser context has associated with it+ * [APIRequestContext](https://playwright.dev/docs/api/class-apirequestcontext) instance which shares cookie storage+ * with the browser context and can be accessed via+ * [browserContext.request](https://playwright.dev/docs/api/class-browsercontext#browser-context-request) or+ * [page.request](https://playwright.dev/docs/api/class-page#page-request). It is also possible to create a new+ * APIRequestContext instance manually by calling+ * [apiRequest.newContext([options])](https://playwright.dev/docs/api/class-apirequest#api-request-new-context).+ *+ * **Cookie management**+ *+ * [APIRequestContext](https://playwright.dev/docs/api/class-apirequestcontext) returned by+ * [browserContext.request](https://playwright.dev/docs/api/class-browsercontext#browser-context-request) and+ * [page.request](https://playwright.dev/docs/api/class-page#page-request) shares cookie storage with the+ * corresponding [BrowserContext](https://playwright.dev/docs/api/class-browsercontext). Each API request will have+ * `Cookie` header populated with the values from the browser context. If the API response contains `Set-Cookie`+ * header it will automatically update [BrowserContext](https://playwright.dev/docs/api/class-browsercontext) cookies+ * and requests made from the page will pick them up. This means that if you log in using this API, your e2e test will+ * be logged in and vice versa.+ *+ * If you want API requests to not interfere with the browser cookies you should create a new+ * [APIRequestContext](https://playwright.dev/docs/api/class-apirequestcontext) by calling+ * [apiRequest.newContext([options])](https://playwright.dev/docs/api/class-apirequest#api-request-new-context). Such+ * `APIRequestContext` object will have its own isolated cookie storage.+ */+export interface APIRequestContext {+ /**+ * Sends HTTP(S) [DELETE](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/DELETE) request and returns its+ * response. The method will populate request cookies from the context and update context cookies from the response.+ * The method will automatically follow redirects.+ * @param url Target URL.+ * @param options+ */+ delete(url: string, options?: {+ /**+ * Allows to set post data of the request. If the data parameter is an object, it will be serialized to json string+ * and `content-type` header will be set to `application/json` if not explicitly set. Otherwise the `content-type`+ * header will be set to `application/octet-stream` if not explicitly set.+ */+ data?: string|Buffer|Serializable;++ /**+ * Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status+ * codes.+ */+ failOnStatusCode?: boolean;++ /**+ * Provides an object that will be serialized as html form using `application/x-www-form-urlencoded` encoding and sent+ * as this request body. If this parameter is specified `content-type` header will be set to+ * `application/x-www-form-urlencoded` unless explicitly provided.+ */+ form?: { [key: string]: string|number|boolean; }|FormData;++ /**+ * Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by+ * it.+ */+ headers?: { [key: string]: string; };++ /**+ * Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.+ */+ ignoreHTTPSErrors?: boolean;++ /**+ * Maximum number of request redirects that will be followed automatically. An error will be thrown if the number is+ * exceeded. Defaults to `20`. Pass `0` to not follow redirects.+ */+ maxRedirects?: number;++ /**+ * Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not+ * retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.+ */+ maxRetries?: number;++ /**+ * Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this+ * request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless+ * explicitly provided. File values can be passed either as+ * [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file+ * name, mime-type and its content.+ */+ multipart?: FormData|{ [key: string]: string|number|boolean|ReadStream|{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }; };++ /**+ * Query parameters to be sent with the URL.+ */+ params?: { [key: string]: string|number|boolean; }|URLSearchParams|string;++ /**+ * Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.+ */+ timeout?: number;+ }): Promise<APIResponse>;++ /**+ * All responses returned by+ * [apiRequestContext.get(url[, options])](https://playwright.dev/docs/api/class-apirequestcontext#api-request-context-get)+ * and similar methods are stored in the memory, so that you can later call+ * [apiResponse.body()](https://playwright.dev/docs/api/class-apiresponse#api-response-body).This method discards all+ * its resources, calling any method on disposed+ * [APIRequestContext](https://playwright.dev/docs/api/class-apirequestcontext) will throw an exception.+ * @param options+ */+ dispose(options?: {+ /**+ * The reason to be reported to the operations interrupted by the context disposal.+ */+ reason?: string;+ }): Promise<void>;++ /**+ * Sends HTTP(S) request and returns its response. The method will populate request cookies from the context and+ * update context cookies from the response. The method will automatically follow redirects.+ *+ * **Usage**+ *+ * JSON objects can be passed directly to the request:+ *+ * ```js+ * await request.fetch('https://example.com/api/createBook', {+ * method: 'post',+ * data: {+ * title: 'Book Title',+ * author: 'John Doe',+ * }+ * });+ * ```+ *+ * The common way to send file(s) in the body of a request is to upload them as form fields with `multipart/form-data`+ * encoding, by specifiying the `multipart` parameter:+ *+ * ```js+ * const form = new FormData();+ * form.set('name', 'John');+ * form.append('name', 'Doe');+ * // Send two file fields with the same name.+ * form.append('file', new File(['console.log(2024);'], 'f1.js', { type: 'text/javascript' }));+ * form.append('file', new File(['hello'], 'f2.txt', { type: 'text/plain' }));+ * await request.fetch('https://example.com/api/uploadForm', {+ * multipart: form+ * });+ * ```+ *+ * @param urlOrRequest Target URL or Request to get all parameters from.+ * @param options+ */+ fetch(urlOrRequest: string|Request, options?: {+ /**+ * Allows to set post data of the request. If the data parameter is an object, it will be serialized to json string+ * and `content-type` header will be set to `application/json` if not explicitly set. Otherwise the `content-type`+ * header will be set to `application/octet-stream` if not explicitly set.+ */+ data?: string|Buffer|Serializable;++ /**+ * Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status+ * codes.+ */+ failOnStatusCode?: boolean;++ /**+ * Provides an object that will be serialized as html form using `application/x-www-form-urlencoded` encoding and sent+ * as this request body. If this parameter is specified `content-type` header will be set to+ * `application/x-www-form-urlencoded` unless explicitly provided.+ */+ form?: { [key: string]: string|number|boolean; }|FormData;++ /**+ * Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by+ * it.+ */+ headers?: { [key: string]: string; };++ /**+ * Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.+ */+ ignoreHTTPSErrors?: boolean;++ /**+ * Maximum number of request redirects that will be followed automatically. An error will be thrown if the number is+ * exceeded. Defaults to `20`. Pass `0` to not follow redirects.+ */+ maxRedirects?: number;++ /**+ * Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not+ * retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.+ */+ maxRetries?: number;++ /**+ * If set changes the fetch method (e.g. [PUT](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT) or+ * [POST](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST)). If not specified, GET method is used.+ */+ method?: string;++ /**+ * Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this+ * request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless+ * explicitly provided. File values can be passed either as+ * [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file+ * name, mime-type and its content.+ */+ multipart?: FormData|{ [key: string]: string|number|boolean|ReadStream|{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }; };++ /**+ * Query parameters to be sent with the URL.+ */+ params?: { [key: string]: string|number|boolean; }|URLSearchParams|string;++ /**+ * Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.+ */+ timeout?: number;+ }): Promise<APIResponse>;++ /**+ * Sends HTTP(S) [GET](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/GET) request and returns its+ * response. The method will populate request cookies from the context and update context cookies from the response.+ * The method will automatically follow redirects.+ *+ * **Usage**+ *+ * Request parameters can be configured with `params` option, they will be serialized into the URL search parameters:+ *+ * ```js+ * // Passing params as object+ * await request.get('https://example.com/api/getText', {+ * params: {+ * 'isbn': '1234',+ * 'page': 23,+ * }+ * });+ *+ * // Passing params as URLSearchParams+ * const searchParams = new URLSearchParams();+ * searchParams.set('isbn', '1234');+ * searchParams.append('page', 23);+ * searchParams.append('page', 24);+ * await request.get('https://example.com/api/getText', { params: searchParams });+ *+ * // Passing params as string+ * const queryString = 'isbn=1234&page=23&page=24';+ * await request.get('https://example.com/api/getText', { params: queryString });+ * ```+ *+ * @param url Target URL.+ * @param options+ */+ get(url: string, options?: {+ /**+ * Allows to set post data of the request. If the data parameter is an object, it will be serialized to json string+ * and `content-type` header will be set to `application/json` if not explicitly set. Otherwise the `content-type`+ * header will be set to `application/octet-stream` if not explicitly set.+ */+ data?: string|Buffer|Serializable;++ /**+ * Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status+ * codes.+ */+ failOnStatusCode?: boolean;++ /**+ * Provides an object that will be serialized as html form using `application/x-www-form-urlencoded` encoding and sent+ * as this request body. If this parameter is specified `content-type` header will be set to+ * `application/x-www-form-urlencoded` unless explicitly provided.+ */+ form?: { [key: string]: string|number|boolean; }|FormData;++ /**+ * Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by+ * it.+ */+ headers?: { [key: string]: string; };++ /**+ * Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.+ */+ ignoreHTTPSErrors?: boolean;++ /**+ * Maximum number of request redirects that will be followed automatically. An error will be thrown if the number is+ * exceeded. Defaults to `20`. Pass `0` to not follow redirects.+ */+ maxRedirects?: number;++ /**+ * Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not+ * retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.+ */+ maxRetries?: number;++ /**+ * Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this+ * request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless+ * explicitly provided. File values can be passed either as+ * [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file+ * name, mime-type and its content.+ */+ multipart?: FormData|{ [key: string]: string|number|boolean|ReadStream|{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }; };++ /**+ * Query parameters to be sent with the URL.+ */+ params?: { [key: string]: string|number|boolean; }|URLSearchParams|string;++ /**+ * Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.+ */+ timeout?: number;+ }): Promise<APIResponse>;++ /**+ * Sends HTTP(S) [HEAD](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/HEAD) request and returns its+ * response. The method will populate request cookies from the context and update context cookies from the response.+ * The method will automatically follow redirects.+ * @param url Target URL.+ * @param options+ */+ head(url: string, options?: {+ /**+ * Allows to set post data of the request. If the data parameter is an object, it will be serialized to json string+ * and `content-type` header will be set to `application/json` if not explicitly set. Otherwise the `content-type`+ * header will be set to `application/octet-stream` if not explicitly set.+ */+ data?: string|Buffer|Serializable;++ /**+ * Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status+ * codes.+ */+ failOnStatusCode?: boolean;++ /**+ * Provides an object that will be serialized as html form using `application/x-www-form-urlencoded` encoding and sent+ * as this request body. If this parameter is specified `content-type` header will be set to+ * `application/x-www-form-urlencoded` unless explicitly provided.+ */+ form?: { [key: string]: string|number|boolean; }|FormData;++ /**+ * Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by+ * it.+ */+ headers?: { [key: string]: string; };++ /**+ * Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.+ */+ ignoreHTTPSErrors?: boolean;++ /**+ * Maximum number of request redirects that will be followed automatically. An error will be thrown if the number is+ * exceeded. Defaults to `20`. Pass `0` to not follow redirects.+ */+ maxRedirects?: number;++ /**+ * Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not+ * retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.+ */+ maxRetries?: number;++ /**+ * Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this+ * request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless+ * explicitly provided. File values can be passed either as+ * [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file+ * name, mime-type and its content.+ */+ multipart?: FormData|{ [key: string]: string|number|boolean|ReadStream|{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }; };++ /**+ * Query parameters to be sent with the URL.+ */+ params?: { [key: string]: string|number|boolean; }|URLSearchParams|string;++ /**+ * Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.+ */+ timeout?: number;+ }): Promise<APIResponse>;++ /**+ * Sends HTTP(S) [PATCH](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) request and returns its+ * response. The method will populate request cookies from the context and update context cookies from the response.+ * The method will automatically follow redirects.+ * @param url Target URL.+ * @param options+ */+ patch(url: string, options?: {+ /**+ * Allows to set post data of the request. If the data parameter is an object, it will be serialized to json string+ * and `content-type` header will be set to `application/json` if not explicitly set. Otherwise the `content-type`+ * header will be set to `application/octet-stream` if not explicitly set.+ */+ data?: string|Buffer|Serializable;++ /**+ * Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status+ * codes.+ */+ failOnStatusCode?: boolean;++ /**+ * Provides an object that will be serialized as html form using `application/x-www-form-urlencoded` encoding and sent+ * as this request body. If this parameter is specified `content-type` header will be set to+ * `application/x-www-form-urlencoded` unless explicitly provided.+ */+ form?: { [key: string]: string|number|boolean; }|FormData;++ /**+ * Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by+ * it.+ */+ headers?: { [key: string]: string; };++ /**+ * Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.+ */+ ignoreHTTPSErrors?: boolean;++ /**+ * Maximum number of request redirects that will be followed automatically. An error will be thrown if the number is+ * exceeded. Defaults to `20`. Pass `0` to not follow redirects.+ */+ maxRedirects?: number;++ /**+ * Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not+ * retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.+ */+ maxRetries?: number;++ /**+ * Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this+ * request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless+ * explicitly provided. File values can be passed either as+ * [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file+ * name, mime-type and its content.+ */+ multipart?: FormData|{ [key: string]: string|number|boolean|ReadStream|{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }; };++ /**+ * Query parameters to be sent with the URL.+ */+ params?: { [key: string]: string|number|boolean; }|URLSearchParams|string;++ /**+ * Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.+ */+ timeout?: number;+ }): Promise<APIResponse>;++ /**+ * Sends HTTP(S) [POST](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST) request and returns its+ * response. The method will populate request cookies from the context and update context cookies from the response.+ * The method will automatically follow redirects.+ *+ * **Usage**+ *+ * JSON objects can be passed directly to the request:+ *+ * ```js+ * await request.post('https://example.com/api/createBook', {+ * data: {+ * title: 'Book Title',+ * author: 'John Doe',+ * }+ * });+ * ```+ *+ * To send form data to the server use `form` option. Its value will be encoded into the request body with+ * `application/x-www-form-urlencoded` encoding (see below how to use `multipart/form-data` form encoding to send+ * files):+ *+ * ```js+ * await request.post('https://example.com/api/findBook', {+ * form: {+ * title: 'Book Title',+ * author: 'John Doe',+ * }+ * });+ * ```+ *+ * The common way to send file(s) in the body of a request is to upload them as form fields with `multipart/form-data`+ * encoding. Use [FormData] to construct request body and pass it to the request as `multipart` parameter:+ *+ * ```js+ * const form = new FormData();+ * form.set('name', 'John');+ * form.append('name', 'Doe');+ * // Send two file fields with the same name.+ * form.append('file', new File(['console.log(2024);'], 'f1.js', { type: 'text/javascript' }));+ * form.append('file', new File(['hello'], 'f2.txt', { type: 'text/plain' }));+ * await request.post('https://example.com/api/uploadForm', {+ * multipart: form+ * });+ * ```+ *+ * @param url Target URL.+ * @param options+ */+ post(url: string, options?: {+ /**+ * Allows to set post data of the request. If the data parameter is an object, it will be serialized to json string+ * and `content-type` header will be set to `application/json` if not explicitly set. Otherwise the `content-type`+ * header will be set to `application/octet-stream` if not explicitly set.+ */+ data?: string|Buffer|Serializable;++ /**+ * Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status+ * codes.+ */+ failOnStatusCode?: boolean;++ /**+ * Provides an object that will be serialized as html form using `application/x-www-form-urlencoded` encoding and sent+ * as this request body. If this parameter is specified `content-type` header will be set to+ * `application/x-www-form-urlencoded` unless explicitly provided.+ */+ form?: { [key: string]: string|number|boolean; }|FormData;++ /**+ * Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by+ * it.+ */+ headers?: { [key: string]: string; };++ /**+ * Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.+ */+ ignoreHTTPSErrors?: boolean;++ /**+ * Maximum number of request redirects that will be followed automatically. An error will be thrown if the number is+ * exceeded. Defaults to `20`. Pass `0` to not follow redirects.+ */+ maxRedirects?: number;++ /**+ * Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not+ * retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.+ */+ maxRetries?: number;++ /**+ * Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this+ * request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless+ * explicitly provided. File values can be passed either as+ * [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file+ * name, mime-type and its content.+ */+ multipart?: FormData|{ [key: string]: string|number|boolean|ReadStream|{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }; };++ /**+ * Query parameters to be sent with the URL.+ */+ params?: { [key: string]: string|number|boolean; }|URLSearchParams|string;++ /**+ * Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.+ */+ timeout?: number;+ }): Promise<APIResponse>;++ /**+ * Sends HTTP(S) [PUT](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT) request and returns its+ * response. The method will populate request cookies from the context and update context cookies from the response.+ * The method will automatically follow redirects.+ * @param url Target URL.+ * @param options+ */+ put(url: string, options?: {+ /**+ * Allows to set post data of the request. If the data parameter is an object, it will be serialized to json string+ * and `content-type` header will be set to `application/json` if not explicitly set. Otherwise the `content-type`+ * header will be set to `application/octet-stream` if not explicitly set.+ */+ data?: string|Buffer|Serializable;++ /**+ * Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status+ * codes.+ */+ failOnStatusCode?: boolean;++ /**+ * Provides an object that will be serialized as html form using `application/x-www-form-urlencoded` encoding and sent+ * as this request body. If this parameter is specified `content-type` header will be set to+ * `application/x-www-form-urlencoded` unless explicitly provided.+ */+ form?: { [key: string]: string|number|boolean; }|FormData;++ /**+ * Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by+ * it.+ */+ headers?: { [key: string]: string; };++ /**+ * Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.+ */+ ignoreHTTPSErrors?: boolean;++ /**+ * Maximum number of request redirects that will be followed automatically. An error will be thrown if the number is+ * exceeded. Defaults to `20`. Pass `0` to not follow redirects.+ */+ maxRedirects?: number;++ /**+ * Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not+ * retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.+ */+ maxRetries?: number;++ /**+ * Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this+ * request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless+ * explicitly provided. File values can be passed either as+ * [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file+ * name, mime-type and its content.+ */+ multipart?: FormData|{ [key: string]: string|number|boolean|ReadStream|{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }; };++ /**+ * Query parameters to be sent with the URL.+ */+ params?: { [key: string]: string|number|boolean; }|URLSearchParams|string;++ /**+ * Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.+ */+ timeout?: number;+ }): Promise<APIResponse>;++ /**+ * Returns storage state for this request context, contains current cookies and local storage snapshot if it was+ * passed to the constructor.+ * @param options+ */+ storageState(options?: {+ /**+ * Defaults to `true`. Set to `false` to omit IndexedDB from snapshot.+ */+ indexedDB?: boolean;++ /**+ * The file path to save the storage state to. If+ * [`path`](https://playwright.dev/docs/api/class-apirequestcontext#api-request-context-storage-state-option-path) is+ * a relative path, then it is resolved relative to current working directory. If no path is provided, storage state+ * is still returned, but won't be saved to the disk.+ */+ path?: string;+ }): Promise<{+ cookies: Array<{+ name: string;++ value: string;++ domain: string;++ path: string;++ /**+ * Unix time in seconds.+ */+ expires: number;++ httpOnly: boolean;++ secure: boolean;++ sameSite: "Strict"|"Lax"|"None";+ }>;++ origins: Array<{+ origin: string;++ localStorage: Array<{+ name: string;++ value: string;+ }>;++ indexedDB: Array<{+ name: string;++ version: number;++ stores: Array<{+ name: string;++ keyPath?: string;++ keyPathArray?: Array<string>;++ autoIncrement: boolean;++ indexes: Array<{+ name: string;++ keyPath?: string;++ keyPathArray?: Array<string>;++ unique: boolean;++ multiEntry: boolean;+ }>;++ records: Array<{+ key?: Object;++ /**+ * if `key` is not JSON-serializable, this contains an encoded version that preserves types.+ */+ keyEncoded?: Object;++ value?: Object;++ /**+ * if `value` is not JSON-serializable, this contains an encoded version that preserves types.+ */+ valueEncoded?: Object;+ }>;+ }>;+ }>;+ }>;+ }>;++ [Symbol.asyncDispose](): Promise<void>;+}++/**+ * [APIResponse](https://playwright.dev/docs/api/class-apiresponse) class represents responses returned by+ * [apiRequestContext.get(url[, options])](https://playwright.dev/docs/api/class-apirequestcontext#api-request-context-get)+ * and similar methods.+ */+export interface APIResponse {+ /**+ * Returns the buffer with response body.+ */+ body(): Promise<Buffer>;++ /**+ * Disposes the body of this response. If not called then the body will stay in memory until the context closes.+ */+ dispose(): Promise<void>;++ /**+ * An object with all the response HTTP headers associated with this response.+ */+ headers(): { [key: string]: string; };++ /**+ * An array with all the response HTTP headers associated with this response. Header names are not lower-cased.+ * Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.+ */+ headersArray(): Array<{+ /**+ * Name of the header.+ */+ name: string;++ /**+ * Value of the header.+ */+ value: string;+ }>;++ /**+ * Returns the JSON representation of response body.+ *+ * This method will throw if the response body is not parsable via `JSON.parse`.+ */+ json(): Promise<Serializable>;++ /**+ * Contains a boolean stating whether the response was successful (status in the range 200-299) or not.+ */+ ok(): boolean;++ /**+ * Contains the status code of the response (e.g., 200 for a success).+ */+ status(): number;++ /**+ * Contains the status text of the response (e.g. usually an "OK" for a success).+ */+ statusText(): string;++ /**+ * Returns the text representation of response body.+ */+ text(): Promise<string>;++ /**+ * Contains the URL of the response.+ */+ url(): string;++ [Symbol.asyncDispose](): Promise<void>;+}++export interface BrowserServer {+ /**+ * Emitted when the browser server closes.+ */+ on(event: 'close', listener: () => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'close', listener: () => any): this;++ /**+ * Emitted when the browser server closes.+ */+ addListener(event: 'close', listener: () => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'close', listener: () => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'close', listener: () => any): this;++ /**+ * Emitted when the browser server closes.+ */+ prependListener(event: 'close', listener: () => any): this;++ /**+ * Closes the browser gracefully and makes sure the process is terminated.+ */+ close(): Promise<void>;++ /**+ * Kills the browser process and waits for the process to exit.+ */+ kill(): Promise<void>;++ /**+ * Spawned browser application process.+ */+ process(): ChildProcess;++ /**+ * Browser websocket url.+ *+ * Browser websocket endpoint which can be used as an argument to+ * [browserType.connect(wsEndpoint[, options])](https://playwright.dev/docs/api/class-browsertype#browser-type-connect)+ * to establish connection to the browser.+ *+ * Note that if the listen `host` option in `launchServer` options is not specified, localhost will be output anyway,+ * even if the actual listening address is an unspecified address.+ */+ wsEndpoint(): string;++ [Symbol.asyncDispose](): Promise<void>;+}++/**+ * Accurately simulating time-dependent behavior is essential for verifying the correctness of applications. Learn+ * more about [clock emulation](https://playwright.dev/docs/clock).+ *+ * Note that clock is installed for the entire [BrowserContext](https://playwright.dev/docs/api/class-browsercontext),+ * so the time in all the pages and iframes is controlled by the same clock.+ */+export interface Clock {+ /**+ * Advance the clock by jumping forward in time. Only fires due timers at most once. This is equivalent to user+ * closing the laptop lid for a while and reopening it later, after given time.+ *+ * **Usage**+ *+ * ```js+ * await page.clock.fastForward(1000);+ * await page.clock.fastForward('30:00');+ * ```+ *+ * @param ticks Time may be the number of milliseconds to advance the clock by or a human-readable string. Valid string formats are+ * "08" for eight seconds, "01:00" for one minute and "02:34:10" for two hours, 34 minutes and ten seconds.+ */+ fastForward(ticks: number|string): Promise<void>;++ /**+ * Install fake implementations for the following time-related functions:+ * - `Date`+ * - `setTimeout`+ * - `clearTimeout`+ * - `setInterval`+ * - `clearInterval`+ * - `requestAnimationFrame`+ * - `cancelAnimationFrame`+ * - `requestIdleCallback`+ * - `cancelIdleCallback`+ * - `performance`+ *+ * Fake timers are used to manually control the flow of time in tests. They allow you to advance time, fire timers,+ * and control the behavior of time-dependent functions. See+ * [clock.runFor(ticks)](https://playwright.dev/docs/api/class-clock#clock-run-for) and+ * [clock.fastForward(ticks)](https://playwright.dev/docs/api/class-clock#clock-fast-forward) for more information.+ * @param options+ */+ install(options?: {+ /**+ * Time to initialize with, current system time by default.+ */+ time?: number|string|Date;+ }): Promise<void>;++ /**+ * Advance the clock by jumping forward in time and pause the time. Once this method is called, no timers are fired+ * unless [clock.runFor(ticks)](https://playwright.dev/docs/api/class-clock#clock-run-for),+ * [clock.fastForward(ticks)](https://playwright.dev/docs/api/class-clock#clock-fast-forward),+ * [clock.pauseAt(time)](https://playwright.dev/docs/api/class-clock#clock-pause-at) or+ * [clock.resume()](https://playwright.dev/docs/api/class-clock#clock-resume) is called.+ *+ * Only fires due timers at most once. This is equivalent to user closing the laptop lid for a while and reopening it+ * at the specified time and pausing.+ *+ * **Usage**+ *+ * ```js+ * await page.clock.pauseAt(new Date('2020-02-02'));+ * await page.clock.pauseAt('2020-02-02');+ * ```+ *+ * For best results, install the clock before navigating the page and set it to a time slightly before the intended+ * test time. This ensures that all timers run normally during page loading, preventing the page from getting stuck.+ * Once the page has fully loaded, you can safely use+ * [clock.pauseAt(time)](https://playwright.dev/docs/api/class-clock#clock-pause-at) to pause the clock.+ *+ * ```js+ * // Initialize clock with some time before the test time and let the page load+ * // naturally. `Date.now` will progress as the timers fire.+ * await page.clock.install({ time: new Date('2024-12-10T08:00:00') });+ * await page.goto('http://localhost:3333');+ * await page.clock.pauseAt(new Date('2024-12-10T10:00:00'));+ * ```+ *+ * @param time Time to pause at.+ */+ pauseAt(time: number|string|Date): Promise<void>;++ /**+ * Resumes timers. Once this method is called, time resumes flowing, timers are fired as usual.+ */+ resume(): Promise<void>;++ /**+ * Advance the clock, firing all the time-related callbacks.+ *+ * **Usage**+ *+ * ```js+ * await page.clock.runFor(1000);+ * await page.clock.runFor('30:00');+ * ```+ *+ * @param ticks Time may be the number of milliseconds to advance the clock by or a human-readable string. Valid string formats are+ * "08" for eight seconds, "01:00" for one minute and "02:34:10" for two hours, 34 minutes and ten seconds.+ */+ runFor(ticks: number|string): Promise<void>;++ /**+ * Makes `Date.now` and `new Date()` return fixed fake time at all times, keeps all the timers running.+ *+ * Use this method for simple scenarios where you only need to test with a predefined time. For more advanced+ * scenarios, use [clock.install([options])](https://playwright.dev/docs/api/class-clock#clock-install) instead. Read+ * docs on [clock emulation](https://playwright.dev/docs/clock) to learn more.+ *+ * **Usage**+ *+ * ```js+ * await page.clock.setFixedTime(Date.now());+ * await page.clock.setFixedTime(new Date('2020-02-02'));+ * await page.clock.setFixedTime('2020-02-02');+ * ```+ *+ * @param time Time to be set in milliseconds.+ */+ setFixedTime(time: number|string|Date): Promise<void>;++ /**+ * Sets system time, but does not trigger any timers. Use this to test how the web page reacts to a time shift, for+ * example switching from summer to winter time, or changing time zones.+ *+ * **Usage**+ *+ * ```js+ * await page.clock.setSystemTime(Date.now());+ * await page.clock.setSystemTime(new Date('2020-02-02'));+ * await page.clock.setSystemTime('2020-02-02');+ * ```+ *+ * @param time Time to be set in milliseconds.+ */+ setSystemTime(time: number|string|Date): Promise<void>;+}++/**+ * [ConsoleMessage](https://playwright.dev/docs/api/class-consolemessage) objects are dispatched by page via the+ * [page.on('console')](https://playwright.dev/docs/api/class-page#page-event-console) event. For each console message+ * logged in the page there will be corresponding event in the Playwright context.+ *+ * ```js+ * // Listen for all console logs+ * page.on('console', msg => console.log(msg.text()));+ *+ * // Listen for all console events and handle errors+ * page.on('console', msg => {+ * if (msg.type() === 'error')+ * console.log(`Error text: "${msg.text()}"`);+ * });+ *+ * // Get the next console log+ * const msgPromise = page.waitForEvent('console');+ * await page.evaluate(() => {+ * console.log('hello', 42, { foo: 'bar' }); // Issue console.log inside the page+ * });+ * const msg = await msgPromise;+ *+ * // Deconstruct console log arguments+ * await msg.args()[0].jsonValue(); // hello+ * await msg.args()[1].jsonValue(); // 42+ * ```+ *+ */+export interface ConsoleMessage {+ /**+ * List of arguments passed to a `console` function call. See also+ * [page.on('console')](https://playwright.dev/docs/api/class-page#page-event-console).+ */+ args(): Array<JSHandle>;++ location(): {+ /**+ * URL of the resource.+ */+ url: string;++ /**+ * 0-based line number in the resource.+ */+ lineNumber: number;++ /**+ * 0-based column number in the resource.+ */+ columnNumber: number;+ };++ /**+ * The page that produced this console message, if any.+ */+ page(): null|Page;++ /**+ * The text of the console message.+ */+ text(): string;++ /**+ * One of the following values: `'log'`, `'debug'`, `'info'`, `'error'`, `'warning'`, `'dir'`, `'dirxml'`, `'table'`,+ * `'trace'`, `'clear'`, `'startGroup'`, `'startGroupCollapsed'`, `'endGroup'`, `'assert'`, `'profile'`,+ * `'profileEnd'`, `'count'`, `'timeEnd'`.+ */+ type(): string;+}++/**+ * Coverage gathers information about parts of JavaScript and CSS that were used by the page.+ *+ * An example of using JavaScript coverage to produce Istanbul report for page load:+ *+ * **NOTE** Coverage APIs are only supported on Chromium-based browsers.+ *+ * ```js+ * const { chromium } = require('playwright');+ * const v8toIstanbul = require('v8-to-istanbul');+ *+ * (async () => {+ * const browser = await chromium.launch();+ * const page = await browser.newPage();+ * await page.coverage.startJSCoverage();+ * await page.goto('https://chromium.org');+ * const coverage = await page.coverage.stopJSCoverage();+ * for (const entry of coverage) {+ * const converter = v8toIstanbul('', 0, { source: entry.source });+ * await converter.load();+ * converter.applyCoverage(entry.functions);+ * console.log(JSON.stringify(converter.toIstanbul()));+ * }+ * await browser.close();+ * })();+ * ```+ *+ */+export interface Coverage {+ /**+ * Returns coverage is started+ * @param options+ */+ startCSSCoverage(options?: {+ /**+ * Whether to reset coverage on every navigation. Defaults to `true`.+ */+ resetOnNavigation?: boolean;+ }): Promise<void>;++ /**+ * Returns coverage is started+ *+ * **NOTE** Anonymous scripts are ones that don't have an associated url. These are scripts that are dynamically+ * created on the page using `eval` or `new Function`. If+ * [`reportAnonymousScripts`](https://playwright.dev/docs/api/class-coverage#coverage-start-js-coverage-option-report-anonymous-scripts)+ * is set to `true`, anonymous scripts will have `__playwright_evaluation_script__` as their URL.+ *+ * @param options+ */+ startJSCoverage(options?: {+ /**+ * Whether anonymous scripts generated by the page should be reported. Defaults to `false`.+ */+ reportAnonymousScripts?: boolean;++ /**+ * Whether to reset coverage on every navigation. Defaults to `true`.+ */+ resetOnNavigation?: boolean;+ }): Promise<void>;++ /**+ * Returns the array of coverage reports for all stylesheets+ *+ * **NOTE** CSS Coverage doesn't include dynamically injected style tags without sourceURLs.+ *+ */+ stopCSSCoverage(): Promise<Array<{+ /**+ * StyleSheet URL+ */+ url: string;++ /**+ * StyleSheet content, if available.+ */+ text?: string;++ /**+ * StyleSheet ranges that were used. Ranges are sorted and non-overlapping.+ */+ ranges: Array<{+ /**+ * A start offset in text, inclusive+ */+ start: number;++ /**+ * An end offset in text, exclusive+ */+ end: number;+ }>;+ }>>;++ /**+ * Returns the array of coverage reports for all scripts+ *+ * **NOTE** JavaScript Coverage doesn't include anonymous scripts by default. However, scripts with sourceURLs are+ * reported.+ *+ */+ stopJSCoverage(): Promise<Array<{+ /**+ * Script URL+ */+ url: string;++ /**+ * Script ID+ */+ scriptId: string;++ /**+ * Script content, if applicable.+ */+ source?: string;++ /**+ * V8-specific coverage format.+ */+ functions: Array<{+ functionName: string;++ isBlockCoverage: boolean;++ ranges: Array<{+ count: number;++ startOffset: number;++ endOffset: number;+ }>;+ }>;+ }>>;+}++/**+ * [Dialog](https://playwright.dev/docs/api/class-dialog) objects are dispatched by page via the+ * [page.on('dialog')](https://playwright.dev/docs/api/class-page#page-event-dialog) event.+ *+ * An example of using `Dialog` class:+ *+ * ```js+ * const { chromium } = require('playwright'); // Or 'firefox' or 'webkit'.+ *+ * (async () => {+ * const browser = await chromium.launch();+ * const page = await browser.newPage();+ * page.on('dialog', async dialog => {+ * console.log(dialog.message());+ * await dialog.dismiss();+ * });+ * await page.evaluate(() => alert('1'));+ * await browser.close();+ * })();+ * ```+ *+ * **NOTE** Dialogs are dismissed automatically, unless there is a+ * [page.on('dialog')](https://playwright.dev/docs/api/class-page#page-event-dialog) listener. When listener is+ * present, it **must** either+ * [dialog.accept([promptText])](https://playwright.dev/docs/api/class-dialog#dialog-accept) or+ * [dialog.dismiss()](https://playwright.dev/docs/api/class-dialog#dialog-dismiss) the dialog - otherwise the page+ * will [freeze](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#never_blocking) waiting for the+ * dialog, and actions like click will never finish.+ *+ */+export interface Dialog {+ /**+ * Returns when the dialog has been accepted.+ * @param promptText A text to enter in prompt. Does not cause any effects if the dialog's `type` is not prompt. Optional.+ */+ accept(promptText?: string): Promise<void>;++ /**+ * If dialog is prompt, returns default prompt value. Otherwise, returns empty string.+ */+ defaultValue(): string;++ /**+ * Returns when the dialog has been dismissed.+ */+ dismiss(): Promise<void>;++ /**+ * A message displayed in the dialog.+ */+ message(): string;++ /**+ * The page that initiated this dialog, if available.+ */+ page(): null|Page;++ /**+ * Returns dialog's type, can be one of `alert`, `beforeunload`, `confirm` or `prompt`.+ */+ type(): string;+}++/**+ * [Download](https://playwright.dev/docs/api/class-download) objects are dispatched by page via the+ * [page.on('download')](https://playwright.dev/docs/api/class-page#page-event-download) event.+ *+ * All the downloaded files belonging to the browser context are deleted when the browser context is closed.+ *+ * Download event is emitted once the download starts. Download path becomes available once download completes.+ *+ * ```js+ * // Start waiting for download before clicking. Note no await.+ * const downloadPromise = page.waitForEvent('download');+ * await page.getByText('Download file').click();+ * const download = await downloadPromise;+ *+ * // Wait for the download process to complete and save the downloaded file somewhere.+ * await download.saveAs('/path/to/save/at/' + download.suggestedFilename());+ * ```+ *+ */+export interface Download {+ /**+ * Cancels a download. Will not fail if the download is already finished or canceled. Upon successful cancellations,+ * `download.failure()` would resolve to `'canceled'`.+ */+ cancel(): Promise<void>;++ /**+ * Returns a readable stream for a successful download, or throws for a failed/canceled download.+ */+ createReadStream(): Promise<Readable>;++ /**+ * Deletes the downloaded file. Will wait for the download to finish if necessary.+ */+ delete(): Promise<void>;++ /**+ * Returns download error if any. Will wait for the download to finish if necessary.+ */+ failure(): Promise<null|string>;++ /**+ * Get the page that the download belongs to.+ */+ page(): Page;++ /**+ * Returns path to the downloaded file for a successful download, or throws for a failed/canceled download. The method+ * will wait for the download to finish if necessary. The method throws when connected remotely.+ *+ * Note that the download's file name is a random GUID, use+ * [download.suggestedFilename()](https://playwright.dev/docs/api/class-download#download-suggested-filename) to get+ * suggested file name.+ */+ path(): Promise<string>;++ /**+ * Copy the download to a user-specified path. It is safe to call this method while the download is still in progress.+ * Will wait for the download to finish if necessary.+ *+ * **Usage**+ *+ * ```js+ * await download.saveAs('/path/to/save/at/' + download.suggestedFilename());+ * ```+ *+ * @param path Path where the download should be copied.+ */+ saveAs(path: string): Promise<void>;++ /**+ * Returns suggested filename for this download. It is typically computed by the browser from the+ * [`Content-Disposition`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition) response+ * header or the `download` attribute. See the spec on [whatwg](https://html.spec.whatwg.org/#downloading-resources).+ * Different browsers can use different logic for computing it.+ */+ suggestedFilename(): string;++ /**+ * Returns downloaded url.+ */+ url(): string;+}++/**+ * Playwright has **experimental** support for Electron automation. You can access electron namespace via:+ *+ * ```js+ * const { _electron } = require('playwright');+ * ```+ *+ * An example of the Electron automation script would be:+ *+ * ```js+ * const { _electron: electron } = require('playwright');+ *+ * (async () => {+ * // Launch Electron app.+ * const electronApp = await electron.launch({ args: ['main.js'] });+ *+ * // Evaluation expression in the Electron context.+ * const appPath = await electronApp.evaluate(async ({ app }) => {+ * // This runs in the main Electron process, parameter here is always+ * // the result of the require('electron') in the main app script.+ * return app.getAppPath();+ * });+ * console.log(appPath);+ *+ * // Get the first window that the app opens, wait if necessary.+ * const window = await electronApp.firstWindow();+ * // Print the title.+ * console.log(await window.title());+ * // Capture a screenshot.+ * await window.screenshot({ path: 'intro.png' });+ * // Direct Electron console to Node terminal.+ * window.on('console', console.log);+ * // Click button.+ * await window.click('text=Click me');+ * // Exit app.+ * await electronApp.close();+ * })();+ * ```+ *+ * **Supported Electron versions are:**+ * - v12.2.0++ * - v13.4.0++ * - v14++ *+ * **Known issues:**+ *+ * If you are not able to launch Electron and it will end up in timeouts during launch, try the following:+ * - Ensure that `nodeCliInspect`+ * ([FuseV1Options.EnableNodeCliInspectArguments](https://www.electronjs.org/docs/latest/tutorial/fuses#nodecliinspect))+ * fuse is **not** set to `false`.+ */+export interface Electron {+ /**+ * Launches electron application specified with the+ * [`executablePath`](https://playwright.dev/docs/api/class-electron#electron-launch-option-executable-path).+ * @param options+ */+ launch(options?: {+ /**+ * Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.+ */+ acceptDownloads?: boolean;++ /**+ * Additional arguments to pass to the application when launching. You typically pass the main script name here.+ */+ args?: Array<string>;++ /**+ * Toggles bypassing page's Content-Security-Policy. Defaults to `false`.+ */+ bypassCSP?: boolean;++ /**+ * Emulates [prefers-colors-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)+ * media feature, supported values are `'light'` and `'dark'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'light'`.+ */+ colorScheme?: null|"light"|"dark"|"no-preference";++ /**+ * Current working directory to launch application from.+ */+ cwd?: string;++ /**+ * Specifies environment variables that will be visible to Electron. Defaults to `process.env`.+ */+ env?: { [key: string]: string; };++ /**+ * Launches given Electron application. If not specified, launches the default Electron executable installed in this+ * package, located at `node_modules/.bin/electron`.+ */+ executablePath?: string;++ /**+ * An object containing additional HTTP headers to be sent with every request. Defaults to none.+ */+ extraHTTPHeaders?: { [key: string]: string; };++ geolocation?: {+ /**+ * Latitude between -90 and 90.+ */+ latitude: number;++ /**+ * Longitude between -180 and 180.+ */+ longitude: number;++ /**+ * Non-negative accuracy value. Defaults to `0`.+ */+ accuracy?: number;+ };++ /**+ * Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If no+ * origin is specified, the username and password are sent to any servers upon unauthorized responses.+ */+ httpCredentials?: {+ username: string;++ password: string;++ /**+ * Restrain sending http credentials on specific origin (scheme://host:port).+ */+ origin?: string;++ /**+ * This option only applies to the requests sent from corresponding+ * [APIRequestContext](https://playwright.dev/docs/api/class-apirequestcontext) and does not affect requests sent from+ * the browser. `'always'` - `Authorization` header with basic authentication credentials will be sent with the each+ * API request. `'unauthorized` - the credentials are only sent when 401 (Unauthorized) response with+ * `WWW-Authenticate` header is received. Defaults to `'unauthorized'`.+ */+ send?: "unauthorized"|"always";+ };++ /**+ * Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.+ */+ ignoreHTTPSErrors?: boolean;++ /**+ * Specify user locale, for example `en-GB`, `de-DE`, etc. Locale will affect `navigator.language` value,+ * `Accept-Language` request header value as well as number and date formatting rules. Defaults to the system default+ * locale. Learn more about emulation in our [emulation guide](https://playwright.dev/docs/emulation#locale--timezone).+ */+ locale?: string;++ /**+ * Whether to emulate network being offline. Defaults to `false`. Learn more about+ * [network emulation](https://playwright.dev/docs/emulation#offline).+ */+ offline?: boolean;++ /**+ * Enables [HAR](http://www.softwareishard.com/blog/har-12-spec) recording for all pages into `recordHar.path` file.+ * If not specified, the HAR is not recorded. Make sure to await+ * [browserContext.close([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-close) for+ * the HAR to be saved.+ */+ recordHar?: {+ /**+ * Optional setting to control whether to omit request content from the HAR. Defaults to `false`. Deprecated, use+ * `content` policy instead.+ */+ omitContent?: boolean;++ /**+ * Optional setting to control resource content management. If `omit` is specified, content is not persisted. If+ * `attach` is specified, resources are persisted as separate files or entries in the ZIP archive. If `embed` is+ * specified, content is stored inline the HAR file as per HAR specification. Defaults to `attach` for `.zip` output+ * files and to `embed` for all other file extensions.+ */+ content?: "omit"|"embed"|"attach";++ /**+ * Path on the filesystem to write the HAR file to. If the file name ends with `.zip`, `content: 'attach'` is used by+ * default.+ */+ path: string;++ /**+ * When set to `minimal`, only record information necessary for routing from HAR. This omits sizes, timing, page,+ * cookies, security and other types of HAR information that are not used when replaying from HAR. Defaults to `full`.+ */+ mode?: "full"|"minimal";++ /**+ * A glob or regex pattern to filter requests that are stored in the HAR. When a+ * [`baseURL`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-base-url) via the context+ * options was provided and the passed URL is a path, it gets merged via the+ * [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor. Defaults to none.+ */+ urlFilter?: string|RegExp;+ };++ /**+ * Enables video recording for all pages into `recordVideo.dir` directory. If not specified videos are not recorded.+ * Make sure to await+ * [browserContext.close([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-close) for+ * videos to be saved.+ */+ recordVideo?: {+ /**+ * Path to the directory to put videos into.+ */+ dir: string;++ /**+ * Optional dimensions of the recorded videos. If not specified the size will be equal to `viewport` scaled down to+ * fit into 800x800. If `viewport` is not configured explicitly the video size defaults to 800x450. Actual picture of+ * each page will be scaled down if necessary to fit the specified size.+ */+ size?: {+ /**+ * Video frame width.+ */+ width: number;++ /**+ * Video frame height.+ */+ height: number;+ };+ };++ /**+ * Maximum time in milliseconds to wait for the application to start. Defaults to `30000` (30 seconds). Pass `0` to+ * disable timeout.+ */+ timeout?: number;++ /**+ * Changes the timezone of the context. See+ * [ICU's metaZones.txt](https://cs.chromium.org/chromium/src/third_party/icu/source/data/misc/metaZones.txt?rcl=faee8bc70570192d82d2978a71e2a615788597d1)+ * for a list of supported timezone IDs. Defaults to the system timezone.+ */+ timezoneId?: string;++ /**+ * If specified, traces are saved into this directory.+ */+ tracesDir?: string;+ }): Promise<ElectronApplication>;+}++/**+ * [FileChooser](https://playwright.dev/docs/api/class-filechooser) objects are dispatched by the page in the+ * [page.on('filechooser')](https://playwright.dev/docs/api/class-page#page-event-file-chooser) event.+ *+ * ```js+ * // Start waiting for file chooser before clicking. Note no await.+ * const fileChooserPromise = page.waitForEvent('filechooser');+ * await page.getByText('Upload file').click();+ * const fileChooser = await fileChooserPromise;+ * await fileChooser.setFiles(path.join(__dirname, 'myfile.pdf'));+ * ```+ *+ */+export interface FileChooser {+ /**+ * Returns input element associated with this file chooser.+ */+ element(): ElementHandle;++ /**+ * Returns whether this file chooser accepts multiple files.+ */+ isMultiple(): boolean;++ /**+ * Returns page this file chooser belongs to.+ */+ page(): Page;++ /**+ * Sets the value of the file input this chooser is associated with. If some of the `filePaths` are relative paths,+ * then they are resolved relative to the current working directory. For empty array, clears the selected files.+ * @param files+ * @param options+ */+ setFiles(files: string|ReadonlyArray<string>|{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }|ReadonlyArray<{+ /**+ * File name+ */+ name: string;++ /**+ * File type+ */+ mimeType: string;++ /**+ * File content+ */+ buffer: Buffer;+ }>, options?: {+ /**+ * This option has no effect.+ * @deprecated This option has no effect.+ */+ noWaitAfter?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+ }): Promise<void>;+}++/**+ * FrameLocator represents a view to the `iframe` on the page. It captures the logic sufficient to retrieve the+ * `iframe` and locate elements in that iframe. FrameLocator can be created with either+ * [locator.contentFrame()](https://playwright.dev/docs/api/class-locator#locator-content-frame),+ * [page.frameLocator(selector)](https://playwright.dev/docs/api/class-page#page-frame-locator) or+ * [locator.frameLocator(selector)](https://playwright.dev/docs/api/class-locator#locator-frame-locator) method.+ *+ * ```js+ * const locator = page.locator('#my-frame').contentFrame().getByText('Submit');+ * await locator.click();+ * ```+ *+ * **Strictness**+ *+ * Frame locators are strict. This means that all operations on frame locators will throw if more than one element+ * matches a given selector.+ *+ * ```js+ * // Throws if there are several frames in DOM:+ * await page.locator('.result-frame').contentFrame().getByRole('button').click();+ *+ * // Works because we explicitly tell locator to pick the first frame:+ * await page.locator('.result-frame').contentFrame().first().getByRole('button').click();+ * ```+ *+ * **Converting Locator to FrameLocator**+ *+ * If you have a [Locator](https://playwright.dev/docs/api/class-locator) object pointing to an `iframe` it can be+ * converted to [FrameLocator](https://playwright.dev/docs/api/class-framelocator) using+ * [locator.contentFrame()](https://playwright.dev/docs/api/class-locator#locator-content-frame).+ *+ * **Converting FrameLocator to Locator**+ *+ * If you have a [FrameLocator](https://playwright.dev/docs/api/class-framelocator) object it can be converted to+ * [Locator](https://playwright.dev/docs/api/class-locator) pointing to the same `iframe` using+ * [frameLocator.owner()](https://playwright.dev/docs/api/class-framelocator#frame-locator-owner).+ */+export interface FrameLocator {+ /**+ * Returns locator to the first matching frame.+ * @deprecated Use [locator.first()](https://playwright.dev/docs/api/class-locator#locator-first) followed by+ * [locator.contentFrame()](https://playwright.dev/docs/api/class-locator#locator-content-frame) instead.+ */+ first(): FrameLocator;++ /**+ * When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements+ * in that iframe.+ * @param selector A selector to use when resolving DOM element.+ */+ frameLocator(selector: string): FrameLocator;++ /**+ * Allows locating elements by their alt text.+ *+ * **Usage**+ *+ * For example, this method will find the image by alt text "Playwright logo":+ *+ * ```html+ * <img alt='Playwright logo'>+ * ```+ *+ * ```js+ * await page.getByAltText('Playwright logo').click();+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByAltText(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating input elements by the text of the associated `<label>` or `aria-labelledby` element, or by the+ * `aria-label` attribute.+ *+ * **Usage**+ *+ * For example, this method will find inputs by label "Username" and "Password" in the following DOM:+ *+ * ```html+ * <input aria-label="Username">+ * <label for="password-input">Password:</label>+ * <input id="password-input">+ * ```+ *+ * ```js+ * await page.getByLabel('Username').fill('john');+ * await page.getByLabel('Password').fill('secret');+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByLabel(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating input elements by the placeholder text.+ *+ * **Usage**+ *+ * For example, consider the following DOM structure.+ *+ * ```html+ * <input type="email" placeholder="[email protected]" />+ * ```+ *+ * You can fill the input after locating it by the placeholder text:+ *+ * ```js+ * await page+ * .getByPlaceholder('[email protected]')+ * .fill('[email protected]');+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByPlaceholder(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating elements by their [ARIA role](https://www.w3.org/TR/wai-aria-1.2/#roles),+ * [ARIA attributes](https://www.w3.org/TR/wai-aria-1.2/#aria-attributes) and+ * [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).+ *+ * **Usage**+ *+ * Consider the following DOM structure.+ *+ * ```html+ * <h3>Sign up</h3>+ * <label>+ * <input type="checkbox" /> Subscribe+ * </label>+ * <br/>+ * <button>Submit</button>+ * ```+ *+ * You can locate each element by it's implicit role:+ *+ * ```js+ * await expect(page.getByRole('heading', { name: 'Sign up' })).toBeVisible();+ *+ * await page.getByRole('checkbox', { name: 'Subscribe' }).check();+ *+ * await page.getByRole('button', { name: /submit/i }).click();+ * ```+ *+ * **Details**+ *+ * Role selector **does not replace** accessibility audits and conformance tests, but rather gives early feedback+ * about the ARIA guidelines.+ *+ * Many html elements have an implicitly [defined role](https://w3c.github.io/html-aam/#html-element-role-mappings)+ * that is recognized by the role selector. You can find all the+ * [supported roles here](https://www.w3.org/TR/wai-aria-1.2/#role_definitions). ARIA guidelines **do not recommend**+ * duplicating implicit roles and attributes by setting `role` and/or `aria-*` attributes to default values.+ * @param role Required aria role.+ * @param options+ */+ getByRole(role: "alert"|"alertdialog"|"application"|"article"|"banner"|"blockquote"|"button"|"caption"|"cell"|"checkbox"|"code"|"columnheader"|"combobox"|"complementary"|"contentinfo"|"definition"|"deletion"|"dialog"|"directory"|"document"|"emphasis"|"feed"|"figure"|"form"|"generic"|"grid"|"gridcell"|"group"|"heading"|"img"|"insertion"|"link"|"list"|"listbox"|"listitem"|"log"|"main"|"marquee"|"math"|"meter"|"menu"|"menubar"|"menuitem"|"menuitemcheckbox"|"menuitemradio"|"navigation"|"none"|"note"|"option"|"paragraph"|"presentation"|"progressbar"|"radio"|"radiogroup"|"region"|"row"|"rowgroup"|"rowheader"|"scrollbar"|"search"|"searchbox"|"separator"|"slider"|"spinbutton"|"status"|"strong"|"subscript"|"superscript"|"switch"|"tab"|"table"|"tablist"|"tabpanel"|"term"|"textbox"|"time"|"timer"|"toolbar"|"tooltip"|"tree"|"treegrid"|"treeitem", options?: {+ /**+ * An attribute that is usually set by `aria-checked` or native `<input type=checkbox>` controls.+ *+ * Learn more about [`aria-checked`](https://www.w3.org/TR/wai-aria-1.2/#aria-checked).+ */+ checked?: boolean;++ /**+ * An attribute that is usually set by `aria-disabled` or `disabled`.+ *+ * **NOTE** Unlike most other attributes, `disabled` is inherited through the DOM hierarchy. Learn more about+ * [`aria-disabled`](https://www.w3.org/TR/wai-aria-1.2/#aria-disabled).+ *+ */+ disabled?: boolean;++ /**+ * Whether [`name`](https://playwright.dev/docs/api/class-framelocator#frame-locator-get-by-role-option-name) is+ * matched exactly: case-sensitive and whole-string. Defaults to false. Ignored when+ * [`name`](https://playwright.dev/docs/api/class-framelocator#frame-locator-get-by-role-option-name) is a regular+ * expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;++ /**+ * An attribute that is usually set by `aria-expanded`.+ *+ * Learn more about [`aria-expanded`](https://www.w3.org/TR/wai-aria-1.2/#aria-expanded).+ */+ expanded?: boolean;++ /**+ * Option that controls whether hidden elements are matched. By default, only non-hidden elements, as+ * [defined by ARIA](https://www.w3.org/TR/wai-aria-1.2/#tree_exclusion), are matched by role selector.+ *+ * Learn more about [`aria-hidden`](https://www.w3.org/TR/wai-aria-1.2/#aria-hidden).+ */+ includeHidden?: boolean;++ /**+ * A number attribute that is usually present for roles `heading`, `listitem`, `row`, `treeitem`, with default values+ * for `<h1>-<h6>` elements.+ *+ * Learn more about [`aria-level`](https://www.w3.org/TR/wai-aria-1.2/#aria-level).+ */+ level?: number;++ /**+ * Option to match the [accessible name](https://w3c.github.io/accname/#dfn-accessible-name). By default, matching is+ * case-insensitive and searches for a substring, use+ * [`exact`](https://playwright.dev/docs/api/class-framelocator#frame-locator-get-by-role-option-exact) to control+ * this behavior.+ *+ * Learn more about [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).+ */+ name?: string|RegExp;++ /**+ * An attribute that is usually set by `aria-pressed`.+ *+ * Learn more about [`aria-pressed`](https://www.w3.org/TR/wai-aria-1.2/#aria-pressed).+ */+ pressed?: boolean;++ /**+ * An attribute that is usually set by `aria-selected`.+ *+ * Learn more about [`aria-selected`](https://www.w3.org/TR/wai-aria-1.2/#aria-selected).+ */+ selected?: boolean;+ }): Locator;++ /**+ * Locate element by the test id.+ *+ * **Usage**+ *+ * Consider the following DOM structure.+ *+ * ```html+ * <button data-testid="directions">Itinéraire</button>+ * ```+ *+ * You can locate the element by it's test id:+ *+ * ```js+ * await page.getByTestId('directions').click();+ * ```+ *+ * **Details**+ *+ * By default, the `data-testid` attribute is used as a test id. Use+ * [selectors.setTestIdAttribute(attributeName)](https://playwright.dev/docs/api/class-selectors#selectors-set-test-id-attribute)+ * to configure a different test id attribute if necessary.+ *+ * ```js+ * // Set custom test id attribute from @playwright/test config:+ * import { defineConfig } from '@playwright/test';+ *+ * export default defineConfig({+ * use: {+ * testIdAttribute: 'data-pw'+ * },+ * });+ * ```+ *+ * @param testId Id to locate the element by.+ */+ getByTestId(testId: string|RegExp): Locator;++ /**+ * Allows locating elements that contain given text.+ *+ * See also [locator.filter([options])](https://playwright.dev/docs/api/class-locator#locator-filter) that allows to+ * match by another criteria, like an accessible role, and then filter by the text content.+ *+ * **Usage**+ *+ * Consider the following DOM structure:+ *+ * ```html+ * <div>Hello <span>world</span></div>+ * <div>Hello</div>+ * ```+ *+ * You can locate by text substring, exact string, or a regular expression:+ *+ * ```js+ * // Matches <span>+ * page.getByText('world');+ *+ * // Matches first <div>+ * page.getByText('Hello world');+ *+ * // Matches second <div>+ * page.getByText('Hello', { exact: true });+ *+ * // Matches both <div>s+ * page.getByText(/Hello/);+ *+ * // Matches second <div>+ * page.getByText(/^hello$/i);+ * ```+ *+ * **Details**+ *+ * Matching by text always normalizes whitespace, even with exact match. For example, it turns multiple spaces into+ * one, turns line breaks into spaces and ignores leading and trailing whitespace.+ *+ * Input elements of the type `button` and `submit` are matched by their `value` instead of the text content. For+ * example, locating by text `"Log in"` matches `<input type=button value="Log in">`.+ * @param text Text to locate the element for.+ * @param options+ */+ getByText(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Allows locating elements by their title attribute.+ *+ * **Usage**+ *+ * Consider the following DOM structure.+ *+ * ```html+ * <span title='Issues count'>25 issues</span>+ * ```+ *+ * You can check the issues count after locating it by the title text:+ *+ * ```js+ * await expect(page.getByTitle('Issues count')).toHaveText('25 issues');+ * ```+ *+ * @param text Text to locate the element for.+ * @param options+ */+ getByTitle(text: string|RegExp, options?: {+ /**+ * Whether to find an exact match: case-sensitive and whole-string. Default to false. Ignored when locating by a+ * regular expression. Note that exact match still trims whitespace.+ */+ exact?: boolean;+ }): Locator;++ /**+ * Returns locator to the last matching frame.+ * @deprecated Use [locator.last()](https://playwright.dev/docs/api/class-locator#locator-last) followed by+ * [locator.contentFrame()](https://playwright.dev/docs/api/class-locator#locator-content-frame) instead.+ */+ last(): FrameLocator;++ /**+ * The method finds an element matching the specified selector in the locator's subtree. It also accepts filter+ * options, similar to [locator.filter([options])](https://playwright.dev/docs/api/class-locator#locator-filter)+ * method.+ *+ * [Learn more about locators](https://playwright.dev/docs/locators).+ * @param selectorOrLocator A selector or locator to use when resolving DOM element.+ * @param options+ */+ locator(selectorOrLocator: string|Locator, options?: {+ /**+ * Narrows down the results of the method to those which contain elements matching this relative locator. For example,+ * `article` that has `text=Playwright` matches `<article><div>Playwright</div></article>`.+ *+ * Inner locator **must be relative** to the outer locator and is queried starting with the outer locator match, not+ * the document root. For example, you can find `content` that has `div` in+ * `<article><content><div>Playwright</div></content></article>`. However, looking for `content` that has `article+ * div` will fail, because the inner locator must be relative and should not use any elements outside the `content`.+ *+ * Note that outer and inner locators must belong to the same frame. Inner locator must not contain+ * [FrameLocator](https://playwright.dev/docs/api/class-framelocator)s.+ */+ has?: Locator;++ /**+ * Matches elements that do not contain an element that matches an inner locator. Inner locator is queried against the+ * outer one. For example, `article` that does not have `div` matches `<article><span>Playwright</span></article>`.+ *+ * Note that outer and inner locators must belong to the same frame. Inner locator must not contain+ * [FrameLocator](https://playwright.dev/docs/api/class-framelocator)s.+ */+ hasNot?: Locator;++ /**+ * Matches elements that do not contain specified text somewhere inside, possibly in a child or a descendant element.+ * When passed a [string], matching is case-insensitive and searches for a substring.+ */+ hasNotText?: string|RegExp;++ /**+ * Matches elements containing specified text somewhere inside, possibly in a child or a descendant element. When+ * passed a [string], matching is case-insensitive and searches for a substring. For example, `"Playwright"` matches+ * `<article><div>Playwright</div></article>`.+ */+ hasText?: string|RegExp;+ }): Locator;++ /**+ * Returns locator to the n-th matching frame. It's zero based, `nth(0)` selects the first frame.+ * @deprecated Use [locator.nth(index)](https://playwright.dev/docs/api/class-locator#locator-nth) followed by+ * [locator.contentFrame()](https://playwright.dev/docs/api/class-locator#locator-content-frame) instead.+ * @param index+ */+ nth(index: number): FrameLocator;++ /**+ * Returns a [Locator](https://playwright.dev/docs/api/class-locator) object pointing to the same `iframe` as this+ * frame locator.+ *+ * Useful when you have a [FrameLocator](https://playwright.dev/docs/api/class-framelocator) object obtained+ * somewhere, and later on would like to interact with the `iframe` element.+ *+ * For a reverse operation, use+ * [locator.contentFrame()](https://playwright.dev/docs/api/class-locator#locator-content-frame).+ *+ * **Usage**+ *+ * ```js+ * const frameLocator = page.locator('iframe[name="embedded"]').contentFrame();+ * // ...+ * const locator = frameLocator.owner();+ * await expect(locator).toBeVisible();+ * ```+ *+ */+ owner(): Locator;+}++/**+ * Keyboard provides an api for managing a virtual keyboard. The high level api is+ * [keyboard.type(text[, options])](https://playwright.dev/docs/api/class-keyboard#keyboard-type), which takes raw+ * characters and generates proper `keydown`, `keypress`/`input`, and `keyup` events on your page.+ *+ * For finer control, you can use [keyboard.down(key)](https://playwright.dev/docs/api/class-keyboard#keyboard-down),+ * [keyboard.up(key)](https://playwright.dev/docs/api/class-keyboard#keyboard-up), and+ * [keyboard.insertText(text)](https://playwright.dev/docs/api/class-keyboard#keyboard-insert-text) to manually fire+ * events as if they were generated from a real keyboard.+ *+ * An example of holding down `Shift` in order to select and delete some text:+ *+ * ```js+ * await page.keyboard.type('Hello World!');+ * await page.keyboard.press('ArrowLeft');+ *+ * await page.keyboard.down('Shift');+ * for (let i = 0; i < ' World'.length; i++)+ * await page.keyboard.press('ArrowLeft');+ * await page.keyboard.up('Shift');+ *+ * await page.keyboard.press('Backspace');+ * // Result text will end up saying 'Hello!'+ * ```+ *+ * An example of pressing uppercase `A`+ *+ * ```js+ * await page.keyboard.press('Shift+KeyA');+ * // or+ * await page.keyboard.press('Shift+A');+ * ```+ *+ * An example to trigger select-all with the keyboard+ *+ * ```js+ * await page.keyboard.press('ControlOrMeta+A');+ * ```+ *+ */+export interface Keyboard {+ /**+ * Dispatches a `keydown` event.+ *+ * [`key`](https://playwright.dev/docs/api/class-keyboard#keyboard-down-option-key) can specify the intended+ * [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) value or a single character+ * to generate the text for. A superset of the+ * [`key`](https://playwright.dev/docs/api/class-keyboard#keyboard-down-option-key) values can be found+ * [here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:+ *+ * `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`,+ * `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,+ * etc.+ *+ * Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,+ * `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.+ *+ * Holding down `Shift` will type the text that corresponds to the+ * [`key`](https://playwright.dev/docs/api/class-keyboard#keyboard-down-option-key) in the upper case.+ *+ * If [`key`](https://playwright.dev/docs/api/class-keyboard#keyboard-down-option-key) is a single character, it is+ * case-sensitive, so the values `a` and `A` will generate different respective texts.+ *+ * If [`key`](https://playwright.dev/docs/api/class-keyboard#keyboard-down-option-key) is a modifier key, `Shift`,+ * `Meta`, `Control`, or `Alt`, subsequent key presses will be sent with that modifier active. To release the modifier+ * key, use [keyboard.up(key)](https://playwright.dev/docs/api/class-keyboard#keyboard-up).+ *+ * After the key is pressed once, subsequent calls to+ * [keyboard.down(key)](https://playwright.dev/docs/api/class-keyboard#keyboard-down) will have+ * [repeat](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/repeat) set to true. To release the key,+ * use [keyboard.up(key)](https://playwright.dev/docs/api/class-keyboard#keyboard-up).+ *+ * **NOTE** Modifier keys DO influence `keyboard.down`. Holding down `Shift` will type the text in upper case.+ *+ * @param key Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.+ */+ down(key: string): Promise<void>;++ /**+ * Dispatches only `input` event, does not emit the `keydown`, `keyup` or `keypress` events.+ *+ * **Usage**+ *+ * ```js+ * page.keyboard.insertText('嗨');+ * ```+ *+ * **NOTE** Modifier keys DO NOT effect `keyboard.insertText`. Holding down `Shift` will not type the text in upper+ * case.+ *+ * @param text Sets input to the specified text value.+ */+ insertText(text: string): Promise<void>;++ /**+ * **NOTE** In most cases, you should use+ * [locator.press(key[, options])](https://playwright.dev/docs/api/class-locator#locator-press) instead.+ *+ * [`key`](https://playwright.dev/docs/api/class-keyboard#keyboard-press-option-key) can specify the intended+ * [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) value or a single character+ * to generate the text for. A superset of the+ * [`key`](https://playwright.dev/docs/api/class-keyboard#keyboard-press-option-key) values can be found+ * [here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:+ *+ * `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`,+ * `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,+ * etc.+ *+ * Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,+ * `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.+ *+ * Holding down `Shift` will type the text that corresponds to the+ * [`key`](https://playwright.dev/docs/api/class-keyboard#keyboard-press-option-key) in the upper case.+ *+ * If [`key`](https://playwright.dev/docs/api/class-keyboard#keyboard-press-option-key) is a single character, it is+ * case-sensitive, so the values `a` and `A` will generate different respective texts.+ *+ * Shortcuts such as `key: "Control+o"`, `key: "Control++` or `key: "Control+Shift+T"` are supported as well. When+ * specified with the modifier, modifier is pressed and being held while the subsequent key is being pressed.+ *+ * **Usage**+ *+ * ```js+ * const page = await browser.newPage();+ * await page.goto('https://keycode.info');+ * await page.keyboard.press('A');+ * await page.screenshot({ path: 'A.png' });+ * await page.keyboard.press('ArrowLeft');+ * await page.screenshot({ path: 'ArrowLeft.png' });+ * await page.keyboard.press('Shift+O');+ * await page.screenshot({ path: 'O.png' });+ * await browser.close();+ * ```+ *+ * Shortcut for [keyboard.down(key)](https://playwright.dev/docs/api/class-keyboard#keyboard-down) and+ * [keyboard.up(key)](https://playwright.dev/docs/api/class-keyboard#keyboard-up).+ * @param key Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.+ * @param options+ */+ press(key: string, options?: {+ /**+ * Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.+ */+ delay?: number;+ }): Promise<void>;++ /**+ * **NOTE** In most cases, you should use+ * [locator.fill(value[, options])](https://playwright.dev/docs/api/class-locator#locator-fill) instead. You only need+ * to press keys one by one if there is special keyboard handling on the page - in this case use+ * [locator.pressSequentially(text[, options])](https://playwright.dev/docs/api/class-locator#locator-press-sequentially).+ *+ * Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.+ *+ * To press a special key, like `Control` or `ArrowDown`, use+ * [keyboard.press(key[, options])](https://playwright.dev/docs/api/class-keyboard#keyboard-press).+ *+ * **Usage**+ *+ * ```js+ * await page.keyboard.type('Hello'); // Types instantly+ * await page.keyboard.type('World', { delay: 100 }); // Types slower, like a user+ * ```+ *+ * **NOTE** Modifier keys DO NOT effect `keyboard.type`. Holding down `Shift` will not type the text in upper case.+ *+ * **NOTE** For characters that are not on a US keyboard, only an `input` event will be sent.+ *+ * @param text A text to type into a focused element.+ * @param options+ */+ type(text: string, options?: {+ /**+ * Time to wait between key presses in milliseconds. Defaults to 0.+ */+ delay?: number;+ }): Promise<void>;++ /**+ * Dispatches a `keyup` event.+ * @param key Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.+ */+ up(key: string): Promise<void>;+}++/**+ * Playwright generates a lot of logs and they are accessible via the pluggable logger sink.+ *+ * ```js+ * const { chromium } = require('playwright'); // Or 'firefox' or 'webkit'.+ *+ * (async () => {+ * const browser = await chromium.launch({+ * logger: {+ * isEnabled: (name, severity) => name === 'api',+ * log: (name, severity, message, args) => console.log(`${name} ${message}`)+ * }+ * });+ * // ...+ * })();+ * ```+ *+ */+export interface Logger {+ /**+ * Determines whether sink is interested in the logger with the given name and severity.+ * @param name logger name+ * @param severity+ */+ isEnabled(name: string, severity: "verbose"|"info"|"warning"|"error"): boolean;++ /**+ * @param name logger name+ * @param severity+ * @param message log message format+ * @param args message arguments+ * @param hints optional formatting hints+ */+ log(name: string, severity: "verbose"|"info"|"warning"|"error", message: string|Error, args: ReadonlyArray<Object>, hints: {+ /**+ * Optional preferred logger color.+ */+ color?: string;+ }): void;+}++/**+ * The Mouse class operates in main-frame CSS pixels relative to the top-left corner of the viewport.+ *+ * Every `page` object has its own Mouse, accessible with+ * [page.mouse](https://playwright.dev/docs/api/class-page#page-mouse).+ *+ * ```js+ * // Using ‘page.mouse’ to trace a 100x100 square.+ * await page.mouse.move(0, 0);+ * await page.mouse.down();+ * await page.mouse.move(0, 100);+ * await page.mouse.move(100, 100);+ * await page.mouse.move(100, 0);+ * await page.mouse.move(0, 0);+ * await page.mouse.up();+ * ```+ *+ */+export interface Mouse {+ /**+ * Shortcut for [mouse.move(x, y[, options])](https://playwright.dev/docs/api/class-mouse#mouse-move),+ * [mouse.down([options])](https://playwright.dev/docs/api/class-mouse#mouse-down),+ * [mouse.up([options])](https://playwright.dev/docs/api/class-mouse#mouse-up).+ * @param x X coordinate relative to the main frame's viewport in CSS pixels.+ * @param y Y coordinate relative to the main frame's viewport in CSS pixels.+ * @param options+ */+ click(x: number, y: number, options?: {+ /**+ * Defaults to `left`.+ */+ button?: "left"|"right"|"middle";++ /**+ * defaults to 1. See [UIEvent.detail].+ */+ clickCount?: number;++ /**+ * Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.+ */+ delay?: number;+ }): Promise<void>;++ /**+ * Shortcut for [mouse.move(x, y[, options])](https://playwright.dev/docs/api/class-mouse#mouse-move),+ * [mouse.down([options])](https://playwright.dev/docs/api/class-mouse#mouse-down),+ * [mouse.up([options])](https://playwright.dev/docs/api/class-mouse#mouse-up),+ * [mouse.down([options])](https://playwright.dev/docs/api/class-mouse#mouse-down) and+ * [mouse.up([options])](https://playwright.dev/docs/api/class-mouse#mouse-up).+ * @param x X coordinate relative to the main frame's viewport in CSS pixels.+ * @param y Y coordinate relative to the main frame's viewport in CSS pixels.+ * @param options+ */+ dblclick(x: number, y: number, options?: {+ /**+ * Defaults to `left`.+ */+ button?: "left"|"right"|"middle";++ /**+ * Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.+ */+ delay?: number;+ }): Promise<void>;++ /**+ * Dispatches a `mousedown` event.+ * @param options+ */+ down(options?: {+ /**+ * Defaults to `left`.+ */+ button?: "left"|"right"|"middle";++ /**+ * defaults to 1. See [UIEvent.detail].+ */+ clickCount?: number;+ }): Promise<void>;++ /**+ * Dispatches a `mousemove` event.+ * @param x X coordinate relative to the main frame's viewport in CSS pixels.+ * @param y Y coordinate relative to the main frame's viewport in CSS pixels.+ * @param options+ */+ move(x: number, y: number, options?: {+ /**+ * Defaults to 1. Sends intermediate `mousemove` events.+ */+ steps?: number;+ }): Promise<void>;++ /**+ * Dispatches a `mouseup` event.+ * @param options+ */+ up(options?: {+ /**+ * Defaults to `left`.+ */+ button?: "left"|"right"|"middle";++ /**+ * defaults to 1. See [UIEvent.detail].+ */+ clickCount?: number;+ }): Promise<void>;++ /**+ * Dispatches a `wheel` event. This method is usually used to manually scroll the page. See+ * [scrolling](https://playwright.dev/docs/input#scrolling) for alternative ways to scroll.+ *+ * **NOTE** Wheel events may cause scrolling if they are not handled, and this method does not wait for the scrolling+ * to finish before returning.+ *+ * @param deltaX Pixels to scroll horizontally.+ * @param deltaY Pixels to scroll vertically.+ */+ wheel(deltaX: number, deltaY: number): Promise<void>;+}++/**+ * This object can be used to launch or connect to Chromium, returning instances of+ * [Browser](https://playwright.dev/docs/api/class-browser).+ */+export const chromium: BrowserType;++/**+ * This object can be used to launch or connect to Firefox, returning instances of+ * [Browser](https://playwright.dev/docs/api/class-browser).+ */+export const firefox: BrowserType;++/**+ * Exposes API that can be used for the Web API testing.+ */+export const request: APIRequest;++/**+ * Selectors can be used to install custom selector engines. See [extensibility](https://playwright.dev/docs/extensibility) for more+ * information.+ */+export const selectors: Selectors;++/**+ * This object can be used to launch or connect to WebKit, returning instances of+ * [Browser](https://playwright.dev/docs/api/class-browser).+ */+export const webkit: BrowserType;++/**+ * Whenever the page sends a request for a network resource the following sequence of events are emitted by+ * [Page](https://playwright.dev/docs/api/class-page):+ * - [page.on('request')](https://playwright.dev/docs/api/class-page#page-event-request) emitted when the request is+ * issued by the page.+ * - [page.on('response')](https://playwright.dev/docs/api/class-page#page-event-response) emitted when/if the+ * response status and headers are received for the request.+ * - [page.on('requestfinished')](https://playwright.dev/docs/api/class-page#page-event-request-finished) emitted+ * when the response body is downloaded and the request is complete.+ *+ * If request fails at some point, then instead of `'requestfinished'` event (and possibly instead of 'response'+ * event), the [page.on('requestfailed')](https://playwright.dev/docs/api/class-page#page-event-request-failed) event+ * is emitted.+ *+ * **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request+ * will complete with `'requestfinished'` event.+ *+ * If request gets a 'redirect' response, the request is successfully finished with the `requestfinished` event, and a+ * new request is issued to a redirected url.+ */+export interface Request {+ /**+ * An object with all the request HTTP headers associated with this request. The header names are lower-cased.+ */+ allHeaders(): Promise<{ [key: string]: string; }>;++ /**+ * The method returns `null` unless this request has failed, as reported by `requestfailed` event.+ *+ * **Usage**+ *+ * Example of logging of all the failed requests:+ *+ * ```js+ * page.on('requestfailed', request => {+ * console.log(request.url() + ' ' + request.failure().errorText);+ * });+ * ```+ *+ */+ failure(): null|{+ /**+ * Human-readable error message, e.g. `'net::ERR_FAILED'`.+ */+ errorText: string;+ };++ /**+ * Returns the [Frame](https://playwright.dev/docs/api/class-frame) that initiated this request.+ *+ * **Usage**+ *+ * ```js+ * const frameUrl = request.frame().url();+ * ```+ *+ * **Details**+ *+ * Note that in some cases the frame is not available, and this method will throw.+ * - When request originates in the Service Worker. You can use `request.serviceWorker()` to check that.+ * - When navigation request is issued before the corresponding frame is created. You can use+ * [request.isNavigationRequest()](https://playwright.dev/docs/api/class-request#request-is-navigation-request) to+ * check that.+ *+ * Here is an example that handles all the cases:+ *+ * ```js+ * if (request.serviceWorker())+ * console.log(`request ${request.url()} from a service worker`);+ * else if (request.isNavigationRequest())+ * console.log(`request ${request.url()} is a navigation request`);+ * else+ * console.log(`request ${request.url()} from a frame ${request.frame().url()}`);+ * ```+ *+ */+ frame(): Frame;++ /**+ * An object with the request HTTP headers. The header names are lower-cased. Note that this method does not return+ * security-related headers, including cookie-related ones. You can use+ * [request.allHeaders()](https://playwright.dev/docs/api/class-request#request-all-headers) for complete list of+ * headers that include `cookie` information.+ */+ headers(): { [key: string]: string; };++ /**+ * An array with all the request HTTP headers associated with this request. Unlike+ * [request.allHeaders()](https://playwright.dev/docs/api/class-request#request-all-headers), header names are NOT+ * lower-cased. Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.+ */+ headersArray(): Promise<Array<{+ /**+ * Name of the header.+ */+ name: string;++ /**+ * Value of the header.+ */+ value: string;+ }>>;++ /**+ * Returns the value of the header matching the name. The name is case-insensitive.+ * @param name Name of the header.+ */+ headerValue(name: string): Promise<null|string>;++ /**+ * Whether this request is driving frame's navigation.+ *+ * Some navigation requests are issued before the corresponding frame is created, and therefore do not have+ * [request.frame()](https://playwright.dev/docs/api/class-request#request-frame) available.+ */+ isNavigationRequest(): boolean;++ /**+ * Request's method (GET, POST, etc.)+ */+ method(): string;++ /**+ * Request's post body, if any.+ */+ postData(): null|string;++ /**+ * Request's post body in a binary form, if any.+ */+ postDataBuffer(): null|Buffer;++ /**+ * Returns parsed request's body for `form-urlencoded` and JSON as a fallback if any.+ *+ * When the response is `application/x-www-form-urlencoded` then a key/value object of the values will be returned.+ * Otherwise it will be parsed as JSON.+ */+ postDataJSON(): null|Serializable;++ /**+ * Request that was redirected by the server to this one, if any.+ *+ * When the server responds with a redirect, Playwright creates a new+ * [Request](https://playwright.dev/docs/api/class-request) object. The two requests are connected by+ * `redirectedFrom()` and `redirectedTo()` methods. When multiple server redirects has happened, it is possible to+ * construct the whole redirect chain by repeatedly calling `redirectedFrom()`.+ *+ * **Usage**+ *+ * For example, if the website `http://example.com` redirects to `https://example.com`:+ *+ * ```js+ * const response = await page.goto('http://example.com');+ * console.log(response.request().redirectedFrom().url()); // 'http://example.com'+ * ```+ *+ * If the website `https://google.com` has no redirects:+ *+ * ```js+ * const response = await page.goto('https://google.com');+ * console.log(response.request().redirectedFrom()); // null+ * ```+ *+ */+ redirectedFrom(): null|Request;++ /**+ * New request issued by the browser if the server responded with redirect.+ *+ * **Usage**+ *+ * This method is the opposite of+ * [request.redirectedFrom()](https://playwright.dev/docs/api/class-request#request-redirected-from):+ *+ * ```js+ * console.log(request.redirectedFrom().redirectedTo() === request); // true+ * ```+ *+ */+ redirectedTo(): null|Request;++ /**+ * Contains the request's resource type as it was perceived by the rendering engine. ResourceType will be one of the+ * following: `document`, `stylesheet`, `image`, `media`, `font`, `script`, `texttrack`, `xhr`, `fetch`,+ * `eventsource`, `websocket`, `manifest`, `other`.+ */+ resourceType(): string;++ /**+ * Returns the matching [Response](https://playwright.dev/docs/api/class-response) object, or `null` if the response+ * was not received due to error.+ */+ response(): Promise<null|Response>;++ /**+ * The Service [Worker](https://playwright.dev/docs/api/class-worker) that is performing the request.+ *+ * **Details**+ *+ * This method is Chromium only. It's safe to call when using other browsers, but it will always be `null`.+ *+ * Requests originated in a Service Worker do not have a+ * [request.frame()](https://playwright.dev/docs/api/class-request#request-frame) available.+ */+ serviceWorker(): null|Worker;++ /**+ * Returns resource size information for given request.+ */+ sizes(): Promise<{+ /**+ * Size of the request body (POST data payload) in bytes. Set to 0 if there was no body.+ */+ requestBodySize: number;++ /**+ * Total number of bytes from the start of the HTTP request message until (and including) the double CRLF before the+ * body.+ */+ requestHeadersSize: number;++ /**+ * Size of the received response body (encoded) in bytes.+ */+ responseBodySize: number;++ /**+ * Total number of bytes from the start of the HTTP response message until (and including) the double CRLF before the+ * body.+ */+ responseHeadersSize: number;+ }>;++ /**+ * Returns resource timing information for given request. Most of the timing values become available upon the+ * response, `responseEnd` becomes available when request finishes. Find more information at+ * [Resource Timing API](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming).+ *+ * **Usage**+ *+ * ```js+ * const requestFinishedPromise = page.waitForEvent('requestfinished');+ * await page.goto('http://example.com');+ * const request = await requestFinishedPromise;+ * console.log(request.timing());+ * ```+ *+ */+ timing(): {+ /**+ * Request start time in milliseconds elapsed since January 1, 1970 00:00:00 UTC+ */+ startTime: number;++ /**+ * Time immediately before the browser starts the domain name lookup for the resource. The value is given in+ * milliseconds relative to `startTime`, -1 if not available.+ */+ domainLookupStart: number;++ /**+ * Time immediately after the browser starts the domain name lookup for the resource. The value is given in+ * milliseconds relative to `startTime`, -1 if not available.+ */+ domainLookupEnd: number;++ /**+ * Time immediately before the user agent starts establishing the connection to the server to retrieve the resource.+ * The value is given in milliseconds relative to `startTime`, -1 if not available.+ */+ connectStart: number;++ /**+ * Time immediately before the browser starts the handshake process to secure the current connection. The value is+ * given in milliseconds relative to `startTime`, -1 if not available.+ */+ secureConnectionStart: number;++ /**+ * Time immediately before the user agent starts establishing the connection to the server to retrieve the resource.+ * The value is given in milliseconds relative to `startTime`, -1 if not available.+ */+ connectEnd: number;++ /**+ * Time immediately before the browser starts requesting the resource from the server, cache, or local resource. The+ * value is given in milliseconds relative to `startTime`, -1 if not available.+ */+ requestStart: number;++ /**+ * Time immediately after the browser receives the first byte of the response from the server, cache, or local+ * resource. The value is given in milliseconds relative to `startTime`, -1 if not available.+ */+ responseStart: number;++ /**+ * Time immediately after the browser receives the last byte of the resource or immediately before the transport+ * connection is closed, whichever comes first. The value is given in milliseconds relative to `startTime`, -1 if not+ * available.+ */+ responseEnd: number;+ };++ /**+ * URL of the request.+ */+ url(): string;+}++/**+ * [Response](https://playwright.dev/docs/api/class-response) class represents responses which are received by page.+ */+export interface Response {+ /**+ * An object with all the response HTTP headers associated with this response.+ */+ allHeaders(): Promise<{ [key: string]: string; }>;++ /**+ * Returns the buffer with response body.+ */+ body(): Promise<Buffer>;++ /**+ * Waits for this response to finish, returns always `null`.+ */+ finished(): Promise<null|Error>;++ /**+ * Returns the [Frame](https://playwright.dev/docs/api/class-frame) that initiated this response.+ */+ frame(): Frame;++ /**+ * Indicates whether this Response was fulfilled by a Service Worker's Fetch Handler (i.e. via+ * [FetchEvent.respondWith](https://developer.mozilla.org/en-US/docs/Web/API/FetchEvent/respondWith)).+ */+ fromServiceWorker(): boolean;++ /**+ * An object with the response HTTP headers. The header names are lower-cased. Note that this method does not return+ * security-related headers, including cookie-related ones. You can use+ * [response.allHeaders()](https://playwright.dev/docs/api/class-response#response-all-headers) for complete list of+ * headers that include `cookie` information.+ */+ headers(): { [key: string]: string; };++ /**+ * An array with all the request HTTP headers associated with this response. Unlike+ * [response.allHeaders()](https://playwright.dev/docs/api/class-response#response-all-headers), header names are NOT+ * lower-cased. Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.+ */+ headersArray(): Promise<Array<{+ /**+ * Name of the header.+ */+ name: string;++ /**+ * Value of the header.+ */+ value: string;+ }>>;++ /**+ * Returns the value of the header matching the name. The name is case-insensitive. If multiple headers have the same+ * name (except `set-cookie`), they are returned as a list separated by `, `. For `set-cookie`, the `\n` separator is+ * used. If no headers are found, `null` is returned.+ * @param name Name of the header.+ */+ headerValue(name: string): Promise<null|string>;++ /**+ * Returns all values of the headers matching the name, for example `set-cookie`. The name is case-insensitive.+ * @param name Name of the header.+ */+ headerValues(name: string): Promise<Array<string>>;++ /**+ * Returns the JSON representation of response body.+ *+ * This method will throw if the response body is not parsable via `JSON.parse`.+ */+ json(): Promise<Serializable>;++ /**+ * Contains a boolean stating whether the response was successful (status in the range 200-299) or not.+ */+ ok(): boolean;++ /**+ * Returns the matching [Request](https://playwright.dev/docs/api/class-request) object.+ */+ request(): Request;++ /**+ * Returns SSL and other security information.+ */+ securityDetails(): Promise<null|{+ /**+ * Common Name component of the Issuer field. from the certificate. This should only be used for informational+ * purposes. Optional.+ */+ issuer?: string;++ /**+ * The specific TLS protocol used. (e.g. `TLS 1.3`). Optional.+ */+ protocol?: string;++ /**+ * Common Name component of the Subject field from the certificate. This should only be used for informational+ * purposes. Optional.+ */+ subjectName?: string;++ /**+ * Unix timestamp (in seconds) specifying when this cert becomes valid. Optional.+ */+ validFrom?: number;++ /**+ * Unix timestamp (in seconds) specifying when this cert becomes invalid. Optional.+ */+ validTo?: number;+ }>;++ /**+ * Returns the IP address and port of the server.+ */+ serverAddr(): Promise<null|{+ /**+ * IPv4 or IPV6 address of the server.+ */+ ipAddress: string;++ port: number;+ }>;++ /**+ * Contains the status code of the response (e.g., 200 for a success).+ */+ status(): number;++ /**+ * Contains the status text of the response (e.g. usually an "OK" for a success).+ */+ statusText(): string;++ /**+ * Returns the text representation of response body.+ */+ text(): Promise<string>;++ /**+ * Contains the URL of the response.+ */+ url(): string;+}++/**+ * Whenever a network route is set up with+ * [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route) or+ * [browserContext.route(url, handler[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-route),+ * the `Route` object allows to handle the route.+ *+ * Learn more about [networking](https://playwright.dev/docs/network).+ */+export interface Route {+ /**+ * Aborts the route's request.+ * @param errorCode Optional error code. Defaults to `failed`, could be one of the following:+ * - `'aborted'` - An operation was aborted (due to user action)+ * - `'accessdenied'` - Permission to access a resource, other than the network, was denied+ * - `'addressunreachable'` - The IP address is unreachable. This usually means that there is no route to the+ * specified host or network.+ * - `'blockedbyclient'` - The client chose to block the request.+ * - `'blockedbyresponse'` - The request failed because the response was delivered along with requirements which are+ * not met ('X-Frame-Options' and 'Content-Security-Policy' ancestor checks, for instance).+ * - `'connectionaborted'` - A connection timed out as a result of not receiving an ACK for data sent.+ * - `'connectionclosed'` - A connection was closed (corresponding to a TCP FIN).+ * - `'connectionfailed'` - A connection attempt failed.+ * - `'connectionrefused'` - A connection attempt was refused.+ * - `'connectionreset'` - A connection was reset (corresponding to a TCP RST).+ * - `'internetdisconnected'` - The Internet connection has been lost.+ * - `'namenotresolved'` - The host name could not be resolved.+ * - `'timedout'` - An operation timed out.+ * - `'failed'` - A generic failure occurred.+ */+ abort(errorCode?: string): Promise<void>;++ /**+ * Sends route's request to the network with optional overrides.+ *+ * **Usage**+ *+ * ```js+ * await page.route('**\/*', async (route, request) => {+ * // Override headers+ * const headers = {+ * ...request.headers(),+ * foo: 'foo-value', // set "foo" header+ * bar: undefined, // remove "bar" header+ * };+ * await route.continue({ headers });+ * });+ * ```+ *+ * **Details**+ *+ * The [`headers`](https://playwright.dev/docs/api/class-route#route-continue-option-headers) option applies to both+ * the routed request and any redirects it initiates. However,+ * [`url`](https://playwright.dev/docs/api/class-route#route-continue-option-url),+ * [`method`](https://playwright.dev/docs/api/class-route#route-continue-option-method), and+ * [`postData`](https://playwright.dev/docs/api/class-route#route-continue-option-post-data) only apply to the+ * original request and are not carried over to redirected requests.+ *+ * [route.continue([options])](https://playwright.dev/docs/api/class-route#route-continue) will immediately send the+ * request to the network, other matching handlers won't be invoked. Use+ * [route.fallback([options])](https://playwright.dev/docs/api/class-route#route-fallback) If you want next matching+ * handler in the chain to be invoked.+ * @param options+ */+ continue(options?: {+ /**+ * If set changes the request HTTP headers. Header values will be converted to a string.+ */+ headers?: { [key: string]: string; };++ /**+ * If set changes the request method (e.g. GET or POST).+ */+ method?: string;++ /**+ * If set changes the post data of request.+ */+ postData?: string|Buffer|Serializable;++ /**+ * If set changes the request URL. New URL must have same protocol as original one.+ */+ url?: string;+ }): Promise<void>;++ /**+ * Continues route's request with optional overrides. The method is similar to+ * [route.continue([options])](https://playwright.dev/docs/api/class-route#route-continue) with the difference that+ * other matching handlers will be invoked before sending the request.+ *+ * **Usage**+ *+ * When several routes match the given pattern, they run in the order opposite to their registration. That way the+ * last registered route can always override all the previous ones. In the example below, request will be handled by+ * the bottom-most handler first, then it'll fall back to the previous one and in the end will be aborted by the first+ * registered route.+ *+ * ```js+ * await page.route('**\/*', async route => {+ * // Runs last.+ * await route.abort();+ * });+ * await page.route('**\/*', async route => {+ * // Runs second.+ * await route.fallback();+ * });+ * await page.route('**\/*', async route => {+ * // Runs first.+ * await route.fallback();+ * });+ * ```+ *+ * Registering multiple routes is useful when you want separate handlers to handle different kinds of requests, for+ * example API calls vs page resources or GET requests vs POST requests as in the example below.+ *+ * ```js+ * // Handle GET requests.+ * await page.route('**\/*', async route => {+ * if (route.request().method() !== 'GET') {+ * await route.fallback();+ * return;+ * }+ * // Handling GET only.+ * // ...+ * });+ *+ * // Handle POST requests.+ * await page.route('**\/*', async route => {+ * if (route.request().method() !== 'POST') {+ * await route.fallback();+ * return;+ * }+ * // Handling POST only.+ * // ...+ * });+ * ```+ *+ * One can also modify request while falling back to the subsequent handler, that way intermediate route handler can+ * modify url, method, headers and postData of the request.+ *+ * ```js+ * await page.route('**\/*', async (route, request) => {+ * // Override headers+ * const headers = {+ * ...request.headers(),+ * foo: 'foo-value', // set "foo" header+ * bar: undefined, // remove "bar" header+ * };+ * await route.fallback({ headers });+ * });+ * ```+ *+ * Use [route.continue([options])](https://playwright.dev/docs/api/class-route#route-continue) to immediately send the+ * request to the network, other matching handlers won't be invoked in that case.+ * @param options+ */+ fallback(options?: {+ /**+ * If set changes the request HTTP headers. Header values will be converted to a string.+ */+ headers?: { [key: string]: string; };++ /**+ * If set changes the request method (e.g. GET or POST).+ */+ method?: string;++ /**+ * If set changes the post data of request.+ */+ postData?: string|Buffer|Serializable;++ /**+ * If set changes the request URL. New URL must have same protocol as original one. Changing the URL won't affect the+ * route matching, all the routes are matched using the original request URL.+ */+ url?: string;+ }): Promise<void>;++ /**+ * Performs the request and fetches result without fulfilling it, so that the response could be modified and then+ * fulfilled.+ *+ * **Usage**+ *+ * ```js+ * await page.route('https://dog.ceo/api/breeds/list/all', async route => {+ * const response = await route.fetch();+ * const json = await response.json();+ * json.message['big_red_dog'] = [];+ * await route.fulfill({ response, json });+ * });+ * ```+ *+ * **Details**+ *+ * Note that [`headers`](https://playwright.dev/docs/api/class-route#route-fetch-option-headers) option will apply to+ * the fetched request as well as any redirects initiated by it. If you want to only apply+ * [`headers`](https://playwright.dev/docs/api/class-route#route-fetch-option-headers) to the original request, but+ * not to redirects, look into [route.continue([options])](https://playwright.dev/docs/api/class-route#route-continue)+ * instead.+ * @param options+ */+ fetch(options?: {+ /**+ * If set changes the request HTTP headers. Header values will be converted to a string.+ */+ headers?: { [key: string]: string; };++ /**+ * Maximum number of request redirects that will be followed automatically. An error will be thrown if the number is+ * exceeded. Defaults to `20`. Pass `0` to not follow redirects.+ */+ maxRedirects?: number;++ /**+ * Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not+ * retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.+ */+ maxRetries?: number;++ /**+ * If set changes the request method (e.g. GET or POST).+ */+ method?: string;++ /**+ * Allows to set post data of the request. If the data parameter is an object, it will be serialized to json string+ * and `content-type` header will be set to `application/json` if not explicitly set. Otherwise the `content-type`+ * header will be set to `application/octet-stream` if not explicitly set.+ */+ postData?: string|Buffer|Serializable;++ /**+ * Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.+ */+ timeout?: number;++ /**+ * If set changes the request URL. New URL must have same protocol as original one.+ */+ url?: string;+ }): Promise<APIResponse>;++ /**+ * Fulfills route's request with given response.+ *+ * **Usage**+ *+ * An example of fulfilling all requests with 404 responses:+ *+ * ```js+ * await page.route('**\/*', async route => {+ * await route.fulfill({+ * status: 404,+ * contentType: 'text/plain',+ * body: 'Not Found!'+ * });+ * });+ * ```+ *+ * An example of serving static file:+ *+ * ```js+ * await page.route('**\/xhr_endpoint', route => route.fulfill({ path: 'mock_data.json' }));+ * ```+ *+ * @param options+ */+ fulfill(options?: {+ /**+ * Response body.+ */+ body?: string|Buffer;++ /**+ * If set, equals to setting `Content-Type` response header.+ */+ contentType?: string;++ /**+ * Response headers. Header values will be converted to a string.+ */+ headers?: { [key: string]: string; };++ /**+ * JSON response. This method will set the content type to `application/json` if not set.+ */+ json?: Serializable;++ /**+ * File path to respond with. The content type will be inferred from file extension. If `path` is a relative path,+ * then it is resolved relative to the current working directory.+ */+ path?: string;++ /**+ * [APIResponse](https://playwright.dev/docs/api/class-apiresponse) to fulfill route's request with. Individual fields+ * of the response (such as headers) can be overridden using fulfill options.+ */+ response?: APIResponse;++ /**+ * Response status code, defaults to `200`.+ */+ status?: number;+ }): Promise<void>;++ /**+ * A request to be routed.+ */+ request(): Request;+}++/**+ * Selectors can be used to install custom selector engines. See [extensibility](https://playwright.dev/docs/extensibility) for more+ * information.+ */+export interface Selectors {+ /**+ * Selectors must be registered before creating the page.+ *+ * **Usage**+ *+ * An example of registering selector engine that queries elements based on a tag name:+ *+ * ```js+ * const { selectors, firefox } = require('@playwright/test'); // Or 'chromium' or 'webkit'.+ *+ * (async () => {+ * // Must be a function that evaluates to a selector engine instance.+ * const createTagNameEngine = () => ({+ * // Returns the first element matching given selector in the root's subtree.+ * query(root, selector) {+ * return root.querySelector(selector);+ * },+ *+ * // Returns all elements matching given selector in the root's subtree.+ * queryAll(root, selector) {+ * return Array.from(root.querySelectorAll(selector));+ * }+ * });+ *+ * // Register the engine. Selectors will be prefixed with "tag=".+ * await selectors.register('tag', createTagNameEngine);+ *+ * const browser = await firefox.launch();+ * const page = await browser.newPage();+ * await page.setContent(`<div><button>Click me</button></div>`);+ *+ * // Use the selector prefixed with its name.+ * const button = page.locator('tag=button');+ * // We can combine it with built-in locators.+ * await page.locator('tag=div').getByText('Click me').click();+ * // Can use it in any methods supporting selectors.+ * const buttonCount = await page.locator('tag=button').count();+ *+ * await browser.close();+ * })();+ * ```+ *+ * @param name Name that is used in selectors as a prefix, e.g. `{name: 'foo'}` enables `foo=myselectorbody` selectors. May only+ * contain `[a-zA-Z0-9_]` characters.+ * @param script Script that evaluates to a selector engine instance. The script is evaluated in the page context.+ * @param options+ */+ register(name: string, script: Function|string|{+ /**+ * Path to the JavaScript file. If `path` is a relative path, then it is resolved relative to the current working+ * directory. Optional.+ */+ path?: string;++ /**+ * Raw script content. Optional.+ */+ content?: string;+ }, options?: {+ /**+ * Whether to run this selector engine in isolated JavaScript environment. This environment has access to the same+ * DOM, but not any JavaScript objects from the frame's scripts. Defaults to `false`. Note that running as a content+ * script is not guaranteed when this engine is used together with other registered engines.+ */+ contentScript?: boolean;+ }): Promise<void>;++ /**+ * Defines custom attribute name to be used in+ * [page.getByTestId(testId)](https://playwright.dev/docs/api/class-page#page-get-by-test-id). `data-testid` is used+ * by default.+ * @param attributeName Test id attribute name.+ */+ setTestIdAttribute(attributeName: string): void;+}++/**+ * The Touchscreen class operates in main-frame CSS pixels relative to the top-left corner of the viewport. Methods on+ * the touchscreen can only be used in browser contexts that have been initialized with `hasTouch` set to true.+ */+export interface Touchscreen {+ /**+ * Dispatches a `touchstart` and `touchend` event with a single touch at the position+ * ([`x`](https://playwright.dev/docs/api/class-touchscreen#touchscreen-tap-option-x),[`y`](https://playwright.dev/docs/api/class-touchscreen#touchscreen-tap-option-y)).+ *+ * **NOTE** [page.tap(selector[, options])](https://playwright.dev/docs/api/class-page#page-tap) the method will throw+ * if [`hasTouch`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-has-touch) option of the+ * browser context is false.+ *+ * @param x X coordinate relative to the main frame's viewport in CSS pixels.+ * @param y Y coordinate relative to the main frame's viewport in CSS pixels.+ */+ tap(x: number, y: number): Promise<void>;+}++/**+ * API for collecting and saving Playwright traces. Playwright traces can be opened in+ * [Trace Viewer](https://playwright.dev/docs/trace-viewer) after Playwright script runs.+ *+ * Start recording a trace before performing actions. At the end, stop tracing and save it to a file.+ *+ * ```js+ * const browser = await chromium.launch();+ * const context = await browser.newContext();+ * await context.tracing.start({ screenshots: true, snapshots: true });+ * const page = await context.newPage();+ * await page.goto('https://playwright.dev');+ * await context.tracing.stop({ path: 'trace.zip' });+ * ```+ *+ */+export interface Tracing {+ /**+ * **NOTE** Use `test.step` instead when available.+ *+ * Creates a new group within the trace, assigning any subsequent API calls to this group, until+ * [tracing.groupEnd()](https://playwright.dev/docs/api/class-tracing#tracing-group-end) is called. Groups can be+ * nested and will be visible in the trace viewer.+ *+ * **Usage**+ *+ * ```js+ * // use test.step instead+ * await test.step('Log in', async () => {+ * // ...+ * });+ * ```+ *+ * @param name Group name shown in the trace viewer.+ * @param options+ */+ group(name: string, options?: {+ /**+ * Specifies a custom location for the group to be shown in the trace viewer. Defaults to the location of the+ * [tracing.group(name[, options])](https://playwright.dev/docs/api/class-tracing#tracing-group) call.+ */+ location?: {+ file: string;++ line?: number;++ column?: number;+ };+ }): Promise<void>;++ /**+ * Closes the last group created by+ * [tracing.group(name[, options])](https://playwright.dev/docs/api/class-tracing#tracing-group).+ */+ groupEnd(): Promise<void>;++ /**+ * Start tracing.+ *+ * **Usage**+ *+ * ```js+ * await context.tracing.start({ screenshots: true, snapshots: true });+ * const page = await context.newPage();+ * await page.goto('https://playwright.dev');+ * await context.tracing.stop({ path: 'trace.zip' });+ * ```+ *+ * @param options+ */+ start(options?: {+ /**+ * If specified, intermediate trace files are going to be saved into the files with the given name prefix inside the+ * [`tracesDir`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-option-traces-dir) directory+ * specified in+ * [browserType.launch([options])](https://playwright.dev/docs/api/class-browsertype#browser-type-launch). To specify+ * the final trace zip file name, you need to pass `path` option to+ * [tracing.stop([options])](https://playwright.dev/docs/api/class-tracing#tracing-stop) instead.+ */+ name?: string;++ /**+ * Whether to capture screenshots during tracing. Screenshots are used to build a timeline preview.+ */+ screenshots?: boolean;++ /**+ * If this option is true tracing will+ * - capture DOM snapshot on every action+ * - record network activity+ */+ snapshots?: boolean;++ /**+ * Whether to include source files for trace actions.+ */+ sources?: boolean;++ /**+ * Trace name to be shown in the Trace Viewer.+ */+ title?: string;+ }): Promise<void>;++ /**+ * Start a new trace chunk. If you'd like to record multiple traces on the same+ * [BrowserContext](https://playwright.dev/docs/api/class-browsercontext), use+ * [tracing.start([options])](https://playwright.dev/docs/api/class-tracing#tracing-start) once, and then create+ * multiple trace chunks with+ * [tracing.startChunk([options])](https://playwright.dev/docs/api/class-tracing#tracing-start-chunk) and+ * [tracing.stopChunk([options])](https://playwright.dev/docs/api/class-tracing#tracing-stop-chunk).+ *+ * **Usage**+ *+ * ```js+ * await context.tracing.start({ screenshots: true, snapshots: true });+ * const page = await context.newPage();+ * await page.goto('https://playwright.dev');+ *+ * await context.tracing.startChunk();+ * await page.getByText('Get Started').click();+ * // Everything between startChunk and stopChunk will be recorded in the trace.+ * await context.tracing.stopChunk({ path: 'trace1.zip' });+ *+ * await context.tracing.startChunk();+ * await page.goto('http://example.com');+ * // Save a second trace file with different actions.+ * await context.tracing.stopChunk({ path: 'trace2.zip' });+ * ```+ *+ * @param options+ */+ startChunk(options?: {+ /**+ * If specified, intermediate trace files are going to be saved into the files with the given name prefix inside the+ * [`tracesDir`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-option-traces-dir) directory+ * specified in+ * [browserType.launch([options])](https://playwright.dev/docs/api/class-browsertype#browser-type-launch). To specify+ * the final trace zip file name, you need to pass `path` option to+ * [tracing.stopChunk([options])](https://playwright.dev/docs/api/class-tracing#tracing-stop-chunk) instead.+ */+ name?: string;++ /**+ * Trace name to be shown in the Trace Viewer.+ */+ title?: string;+ }): Promise<void>;++ /**+ * Stop tracing.+ * @param options+ */+ stop(options?: {+ /**+ * Export trace into the file with the given path.+ */+ path?: string;+ }): Promise<void>;++ /**+ * Stop the trace chunk. See+ * [tracing.startChunk([options])](https://playwright.dev/docs/api/class-tracing#tracing-start-chunk) for more details+ * about multiple trace chunks.+ * @param options+ */+ stopChunk(options?: {+ /**+ * Export trace collected since the last+ * [tracing.startChunk([options])](https://playwright.dev/docs/api/class-tracing#tracing-start-chunk) call into the+ * file with the given path.+ */+ path?: string;+ }): Promise<void>;+}++/**+ * When browser context is created with the `recordVideo` option, each page has a video object associated with it.+ *+ * ```js+ * console.log(await page.video().path());+ * ```+ *+ */+export interface Video {+ /**+ * Deletes the video file. Will wait for the video to finish if necessary.+ */+ delete(): Promise<void>;++ /**+ * Returns the file system path this video will be recorded to. The video is guaranteed to be written to the+ * filesystem upon closing the browser context. This method throws when connected remotely.+ */+ path(): Promise<string>;++ /**+ * Saves the video to a user-specified path. It is safe to call this method while the video is still in progress, or+ * after the page has closed. This method waits until the page is closed and the video is fully saved.+ * @param path Path where the video should be saved.+ */+ saveAs(path: string): Promise<void>;+}++/**+ * [WebError](https://playwright.dev/docs/api/class-weberror) class represents an unhandled exception thrown in the+ * page. It is dispatched via the+ * [browserContext.on('weberror')](https://playwright.dev/docs/api/class-browsercontext#browser-context-event-web-error)+ * event.+ *+ * ```js+ * // Log all uncaught errors to the terminal+ * context.on('weberror', webError => {+ * console.log(`Uncaught exception: "${webError.error()}"`);+ * });+ *+ * // Navigate to a page with an exception.+ * await page.goto('data:text/html,<script>throw new Error("Test")</script>');+ * ```+ *+ */+export interface WebError {+ /**+ * Unhandled error that was thrown.+ */+ error(): Error;++ /**+ * The page that produced this unhandled exception, if any.+ */+ page(): null|Page;+}++/**+ * The [WebSocket](https://playwright.dev/docs/api/class-websocket) class represents WebSocket connections within a+ * page. It provides the ability to inspect and manipulate the data being transmitted and received.+ *+ * If you want to intercept or modify WebSocket frames, consider using+ * [WebSocketRoute](https://playwright.dev/docs/api/class-websocketroute).+ */+export interface WebSocket {+ /**+ * Fired when the websocket closes.+ */+ on(event: 'close', listener: (webSocket: WebSocket) => any): this;++ /**+ * Fired when the websocket receives a frame.+ */+ on(event: 'framereceived', listener: (data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => any): this;++ /**+ * Fired when the websocket sends a frame.+ */+ on(event: 'framesent', listener: (data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => any): this;++ /**+ * Fired when the websocket has an error.+ */+ on(event: 'socketerror', listener: (string: string) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'close', listener: (webSocket: WebSocket) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'framereceived', listener: (data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'framesent', listener: (data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => any): this;++ /**+ * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.+ */+ once(event: 'socketerror', listener: (string: string) => any): this;++ /**+ * Fired when the websocket closes.+ */+ addListener(event: 'close', listener: (webSocket: WebSocket) => any): this;++ /**+ * Fired when the websocket receives a frame.+ */+ addListener(event: 'framereceived', listener: (data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => any): this;++ /**+ * Fired when the websocket sends a frame.+ */+ addListener(event: 'framesent', listener: (data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => any): this;++ /**+ * Fired when the websocket has an error.+ */+ addListener(event: 'socketerror', listener: (string: string) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'close', listener: (webSocket: WebSocket) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'framereceived', listener: (data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'framesent', listener: (data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ removeListener(event: 'socketerror', listener: (string: string) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'close', listener: (webSocket: WebSocket) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'framereceived', listener: (data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'framesent', listener: (data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => any): this;++ /**+ * Removes an event listener added by `on` or `addListener`.+ */+ off(event: 'socketerror', listener: (string: string) => any): this;++ /**+ * Fired when the websocket closes.+ */+ prependListener(event: 'close', listener: (webSocket: WebSocket) => any): this;++ /**+ * Fired when the websocket receives a frame.+ */+ prependListener(event: 'framereceived', listener: (data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => any): this;++ /**+ * Fired when the websocket sends a frame.+ */+ prependListener(event: 'framesent', listener: (data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => any): this;++ /**+ * Fired when the websocket has an error.+ */+ prependListener(event: 'socketerror', listener: (string: string) => any): this;++ /**+ * Indicates that the web socket has been closed.+ */+ isClosed(): boolean;++ /**+ * Contains the URL of the WebSocket.+ */+ url(): string;++ /**+ * Fired when the websocket closes.+ */+ waitForEvent(event: 'close', optionsOrPredicate?: { predicate?: (webSocket: WebSocket) => boolean | Promise<boolean>, timeout?: number } | ((webSocket: WebSocket) => boolean | Promise<boolean>)): Promise<WebSocket>;++ /**+ * Fired when the websocket receives a frame.+ */+ waitForEvent(event: 'framereceived', optionsOrPredicate?: { predicate?: (data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => boolean | Promise<boolean>, timeout?: number } | ((data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => boolean | Promise<boolean>)): Promise<{+ /**+ * frame payload+ */+ payload: string|Buffer;+ }>;++ /**+ * Fired when the websocket sends a frame.+ */+ waitForEvent(event: 'framesent', optionsOrPredicate?: { predicate?: (data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => boolean | Promise<boolean>, timeout?: number } | ((data: {+ /**+ * frame payload+ */+ payload: string|Buffer;+ }) => boolean | Promise<boolean>)): Promise<{+ /**+ * frame payload+ */+ payload: string|Buffer;+ }>;++ /**+ * Fired when the websocket has an error.+ */+ waitForEvent(event: 'socketerror', optionsOrPredicate?: { predicate?: (string: string) => boolean | Promise<boolean>, timeout?: number } | ((string: string) => boolean | Promise<boolean>)): Promise<string>;++}++interface AccessibilitySnapshotOptions {+ /**+ * Prune uninteresting nodes from the tree. Defaults to `true`.+ */+ interestingOnly?: boolean;++ /**+ * The root DOM element for the snapshot. Defaults to the whole page.+ */+ root?: ElementHandle;+}++export interface LaunchOptions {+ /**+ * **NOTE** Use custom browser args at your own risk, as some of them may break Playwright functionality.+ *+ * Additional arguments to pass to the browser instance. The list of Chromium flags can be found+ * [here](https://peter.sh/experiments/chromium-command-line-switches/).+ */+ args?: Array<string>;++ /**+ * Browser distribution channel.+ *+ * Use "chromium" to [opt in to new headless mode](https://playwright.dev/docs/browsers#chromium-new-headless-mode).+ *+ * Use "chrome", "chrome-beta", "chrome-dev", "chrome-canary", "msedge", "msedge-beta", "msedge-dev", or+ * "msedge-canary" to use branded [Google Chrome and Microsoft Edge](https://playwright.dev/docs/browsers#google-chrome--microsoft-edge).+ */+ channel?: string;++ /**+ * Enable Chromium sandboxing. Defaults to `false`.+ */+ chromiumSandbox?: boolean;++ /**+ * **Chromium-only** Whether to auto-open a Developer Tools panel for each tab. If this option is `true`, the+ * [`headless`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-option-headless) option will be+ * set `false`.+ * @deprecated Use [debugging tools](https://playwright.dev/docs/debug) instead.+ */+ devtools?: boolean;++ /**+ * If specified, accepted downloads are downloaded into this directory. Otherwise, temporary directory is created and+ * is deleted when browser is closed. In either case, the downloads are deleted when the browser context they were+ * created in is closed.+ */+ downloadsPath?: string;++ /**+ * Specify environment variables that will be visible to the browser. Defaults to `process.env`.+ */+ env?: { [key: string]: string|number|boolean; };++ /**+ * Path to a browser executable to run instead of the bundled one. If+ * [`executablePath`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-option-executable-path) is+ * a relative path, then it is resolved relative to the current working directory. Note that Playwright only works+ * with the bundled Chromium, Firefox or WebKit, use at your own risk.+ */+ executablePath?: string;++ /**+ * Firefox user preferences. Learn more about the Firefox user preferences at+ * [`about:config`](https://support.mozilla.org/en-US/kb/about-config-editor-firefox).+ */+ firefoxUserPrefs?: { [key: string]: string|number|boolean; };++ /**+ * Close the browser process on SIGHUP. Defaults to `true`.+ */+ handleSIGHUP?: boolean;++ /**+ * Close the browser process on Ctrl-C. Defaults to `true`.+ */+ handleSIGINT?: boolean;++ /**+ * Close the browser process on SIGTERM. Defaults to `true`.+ */+ handleSIGTERM?: boolean;++ /**+ * Whether to run browser in headless mode. More details for+ * [Chromium](https://developers.google.com/web/updates/2017/04/headless-chrome) and+ * [Firefox](https://developer.mozilla.org/en-US/docs/Mozilla/Firefox/Headless_mode). Defaults to `true` unless the+ * [`devtools`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-option-devtools) option is+ * `true`.+ */+ headless?: boolean;++ /**+ * If `true`, Playwright does not pass its own configurations args and only uses the ones from+ * [`args`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch-option-args). If an array is given,+ * then filters out the given default arguments. Dangerous option; use with care. Defaults to `false`.+ */+ ignoreDefaultArgs?: boolean|Array<string>;++ /**+ * Logger sink for Playwright logging.+ */+ logger?: Logger;++ /**+ * Network proxy settings.+ */+ proxy?: {+ /**+ * Proxy to be used for all requests. HTTP and SOCKS proxies are supported, for example `http://myproxy.com:3128` or+ * `socks5://myproxy.com:3128`. Short form `myproxy.com:3128` is considered an HTTP proxy.+ */+ server: string;++ /**+ * Optional comma-separated domains to bypass proxy, for example `".com, chromium.org, .domain.com"`.+ */+ bypass?: string;++ /**+ * Optional username to use if HTTP proxy requires authentication.+ */+ username?: string;++ /**+ * Optional password to use if HTTP proxy requires authentication.+ */+ password?: string;+ };++ /**+ * Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going+ * on.+ */+ slowMo?: number;++ /**+ * Maximum time in milliseconds to wait for the browser instance to start. Defaults to `30000` (30 seconds). Pass `0`+ * to disable timeout.+ */+ timeout?: number;++ /**+ * If specified, traces are saved into this directory.+ */+ tracesDir?: string;+}++export interface ConnectOverCDPOptions {+ /**+ * Deprecated, use the first argument instead. Optional.+ */+ endpointURL?: string;++ /**+ * Additional HTTP headers to be sent with connect request. Optional.+ */+ headers?: { [key: string]: string; };++ /**+ * Logger sink for Playwright logging. Optional.+ */+ logger?: Logger;++ /**+ * Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going+ * on. Defaults to 0.+ */+ slowMo?: number;++ /**+ * Maximum time in milliseconds to wait for the connection to be established. Defaults to `30000` (30 seconds). Pass+ * `0` to disable timeout.+ */+ timeout?: number;+}++export interface ConnectOptions {+ /**+ * This option exposes network available on the connecting client to the browser being connected to. Consists of a+ * list of rules separated by comma.+ *+ * Available rules:+ * 1. Hostname pattern, for example: `example.com`, `*.org:99`, `x.*.y.com`, `*foo.org`.+ * 1. IP literal, for example: `127.0.0.1`, `0.0.0.0:99`, `[::1]`, `[0:0::1]:99`.+ * 1. `<loopback>` that matches local loopback interfaces: `localhost`, `*.localhost`, `127.0.0.1`, `[::1]`.+ *+ * Some common examples:+ * 1. `"*"` to expose all network.+ * 1. `"<loopback>"` to expose localhost network.+ * 1. `"*.test.internal-domain,*.staging.internal-domain,<loopback>"` to expose test/staging deployments and+ * localhost.+ */+ exposeNetwork?: string;++ /**+ * Additional HTTP headers to be sent with web socket connect request. Optional.+ */+ headers?: { [key: string]: string; };++ /**+ * Logger sink for Playwright logging. Optional.+ */+ logger?: Logger;++ /**+ * Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going+ * on. Defaults to 0.+ */+ slowMo?: number;++ /**+ * Maximum time in milliseconds to wait for the connection to be established. Defaults to `0` (no timeout).+ */+ timeout?: number;+}++export interface LocatorScreenshotOptions {+ /**+ * When set to `"disabled"`, stops CSS animations, CSS transitions and Web Animations. Animations get different+ * treatment depending on their duration:+ * - finite animations are fast-forwarded to completion, so they'll fire `transitionend` event.+ * - infinite animations are canceled to initial state, and then played over after the screenshot.+ *+ * Defaults to `"allow"` that leaves animations untouched.+ */+ animations?: "disabled"|"allow";++ /**+ * When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be+ * changed. Defaults to `"hide"`.+ */+ caret?: "hide"|"initial";++ /**+ * Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink+ * box `#FF00FF` (customized by+ * [`maskColor`](https://playwright.dev/docs/api/class-locator#locator-screenshot-option-mask-color)) that completely+ * covers its bounding box.+ */+ mask?: Array<Locator>;++ /**+ * Specify the color of the overlay box for masked elements, in+ * [CSS color format](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value). Default color is pink `#FF00FF`.+ */+ maskColor?: string;++ /**+ * Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images.+ * Defaults to `false`.+ */+ omitBackground?: boolean;++ /**+ * The file path to save the image to. The screenshot type will be inferred from file extension. If+ * [`path`](https://playwright.dev/docs/api/class-locator#locator-screenshot-option-path) is a relative path, then it+ * is resolved relative to the current working directory. If no path is provided, the image won't be saved to the+ * disk.+ */+ path?: string;++ /**+ * The quality of the image, between 0-100. Not applicable to `png` images.+ */+ quality?: number;++ /**+ * When set to `"css"`, screenshot will have a single pixel per each css pixel on the page. For high-dpi devices, this+ * will keep screenshots small. Using `"device"` option will produce a single pixel per each device pixel, so+ * screenshots of high-dpi devices will be twice as large or even larger.+ *+ * Defaults to `"device"`.+ */+ scale?: "css"|"device";++ /**+ * Text of the stylesheet to apply while making the screenshot. This is where you can hide dynamic elements, make+ * elements invisible or change their properties to help you creating repeatable screenshots. This stylesheet pierces+ * the Shadow DOM and applies to the inner frames.+ */+ style?: string;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * Specify screenshot type, defaults to `png`.+ */+ type?: "png"|"jpeg";+}++interface ElementHandleWaitForSelectorOptions {+ /**+ * Defaults to `'visible'`. Can be either:+ * - `'attached'` - wait for element to be present in DOM.+ * - `'detached'` - wait for element to not be present in DOM.+ * - `'visible'` - wait for element to have non-empty bounding box and no `visibility:hidden`. Note that element+ * without any content or with `display:none` has an empty bounding box and is not considered visible.+ * - `'hidden'` - wait for element to be either detached from DOM, or have an empty bounding box or+ * `visibility:hidden`. This is opposite to the `'visible'` option.+ */+ state?: "attached"|"detached"|"visible"|"hidden";++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+}++export interface BrowserContextOptions {+ /**+ * Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.+ */+ acceptDownloads?: boolean;++ /**+ * An object containing an option to throw an error when API request returns status codes other than 2xx and 3xx. By+ * default, response object is returned for all status codes.+ */+ apiRequestFailsOnErrorStatus?: boolean;++ /**+ * When using [page.goto(url[, options])](https://playwright.dev/docs/api/class-page#page-goto),+ * [page.route(url, handler[, options])](https://playwright.dev/docs/api/class-page#page-route),+ * [page.waitForURL(url[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-url),+ * [page.waitForRequest(urlOrPredicate[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-request),+ * or+ * [page.waitForResponse(urlOrPredicate[, options])](https://playwright.dev/docs/api/class-page#page-wait-for-response)+ * it takes the base URL in consideration by using the+ * [`URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor for building the corresponding URL.+ * Unset by default. Examples:+ * - baseURL: `http://localhost:3000` and navigating to `/bar.html` results in `http://localhost:3000/bar.html`+ * - baseURL: `http://localhost:3000/foo/` and navigating to `./bar.html` results in+ * `http://localhost:3000/foo/bar.html`+ * - baseURL: `http://localhost:3000/foo` (without trailing slash) and navigating to `./bar.html` results in+ * `http://localhost:3000/bar.html`+ */+ baseURL?: string;++ /**+ * Toggles bypassing page's Content-Security-Policy. Defaults to `false`.+ */+ bypassCSP?: boolean;++ /**+ * TLS Client Authentication allows the server to request a client certificate and verify it.+ *+ * **Details**+ *+ * An array of client certificates to be used. Each certificate object must have either both `certPath` and `keyPath`,+ * a single `pfxPath`, or their corresponding direct value equivalents (`cert` and `key`, or `pfx`). Optionally,+ * `passphrase` property should be provided if the certificate is encrypted. The `origin` property should be provided+ * with an exact match to the request origin that the certificate is valid for.+ *+ * **NOTE** When using WebKit on macOS, accessing `localhost` will not pick up client certificates. You can make it+ * work by replacing `localhost` with `local.playwright`.+ *+ */+ clientCertificates?: Array<{+ /**+ * Exact origin that the certificate is valid for. Origin includes `https` protocol, a hostname and optionally a port.+ */+ origin: string;++ /**+ * Path to the file with the certificate in PEM format.+ */+ certPath?: string;++ /**+ * Direct value of the certificate in PEM format.+ */+ cert?: Buffer;++ /**+ * Path to the file with the private key in PEM format.+ */+ keyPath?: string;++ /**+ * Direct value of the private key in PEM format.+ */+ key?: Buffer;++ /**+ * Path to the PFX or PKCS12 encoded private key and certificate chain.+ */+ pfxPath?: string;++ /**+ * Direct value of the PFX or PKCS12 encoded private key and certificate chain.+ */+ pfx?: Buffer;++ /**+ * Passphrase for the private key (PEM or PFX).+ */+ passphrase?: string;+ }>;++ /**+ * Emulates [prefers-colors-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)+ * media feature, supported values are `'light'` and `'dark'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'light'`.+ */+ colorScheme?: null|"light"|"dark"|"no-preference";++ /**+ * Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'no-preference'`.+ */+ contrast?: null|"no-preference"|"more";++ /**+ * Specify device scale factor (can be thought of as dpr). Defaults to `1`. Learn more about+ * [emulating devices with device scale factor](https://playwright.dev/docs/emulation#devices).+ */+ deviceScaleFactor?: number;++ /**+ * An object containing additional HTTP headers to be sent with every request. Defaults to none.+ */+ extraHTTPHeaders?: { [key: string]: string; };++ /**+ * Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'none'`.+ */+ forcedColors?: null|"active"|"none";++ geolocation?: Geolocation;++ /**+ * Specifies if viewport supports touch events. Defaults to false. Learn more about+ * [mobile emulation](https://playwright.dev/docs/emulation#devices).+ */+ hasTouch?: boolean;++ /**+ * Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If no+ * origin is specified, the username and password are sent to any servers upon unauthorized responses.+ */+ httpCredentials?: HTTPCredentials;++ /**+ * Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.+ */+ ignoreHTTPSErrors?: boolean;++ /**+ * Whether the `meta viewport` tag is taken into account and touch events are enabled. isMobile is a part of device,+ * so you don't actually need to set it manually. Defaults to `false` and is not supported in Firefox. Learn more+ * about [mobile emulation](https://playwright.dev/docs/emulation#ismobile).+ */+ isMobile?: boolean;++ /**+ * Whether or not to enable JavaScript in the context. Defaults to `true`. Learn more about+ * [disabling JavaScript](https://playwright.dev/docs/emulation#javascript-enabled).+ */+ javaScriptEnabled?: boolean;++ /**+ * Specify user locale, for example `en-GB`, `de-DE`, etc. Locale will affect `navigator.language` value,+ * `Accept-Language` request header value as well as number and date formatting rules. Defaults to the system default+ * locale. Learn more about emulation in our [emulation guide](https://playwright.dev/docs/emulation#locale--timezone).+ */+ locale?: string;++ /**+ * Logger sink for Playwright logging.+ */+ logger?: Logger;++ /**+ * Whether to emulate network being offline. Defaults to `false`. Learn more about+ * [network emulation](https://playwright.dev/docs/emulation#offline).+ */+ offline?: boolean;++ /**+ * A list of permissions to grant to all pages in this context. See+ * [browserContext.grantPermissions(permissions[, options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-grant-permissions)+ * for more details. Defaults to none.+ */+ permissions?: Array<string>;++ /**+ * Network proxy settings to use with this context. Defaults to none.+ */+ proxy?: {+ /**+ * Proxy to be used for all requests. HTTP and SOCKS proxies are supported, for example `http://myproxy.com:3128` or+ * `socks5://myproxy.com:3128`. Short form `myproxy.com:3128` is considered an HTTP proxy.+ */+ server: string;++ /**+ * Optional comma-separated domains to bypass proxy, for example `".com, chromium.org, .domain.com"`.+ */+ bypass?: string;++ /**+ * Optional username to use if HTTP proxy requires authentication.+ */+ username?: string;++ /**+ * Optional password to use if HTTP proxy requires authentication.+ */+ password?: string;+ };++ /**+ * Enables [HAR](http://www.softwareishard.com/blog/har-12-spec) recording for all pages into `recordHar.path` file.+ * If not specified, the HAR is not recorded. Make sure to await+ * [browserContext.close([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-close) for+ * the HAR to be saved.+ */+ recordHar?: {+ /**+ * Optional setting to control whether to omit request content from the HAR. Defaults to `false`. Deprecated, use+ * `content` policy instead.+ */+ omitContent?: boolean;++ /**+ * Optional setting to control resource content management. If `omit` is specified, content is not persisted. If+ * `attach` is specified, resources are persisted as separate files or entries in the ZIP archive. If `embed` is+ * specified, content is stored inline the HAR file as per HAR specification. Defaults to `attach` for `.zip` output+ * files and to `embed` for all other file extensions.+ */+ content?: "omit"|"embed"|"attach";++ /**+ * Path on the filesystem to write the HAR file to. If the file name ends with `.zip`, `content: 'attach'` is used by+ * default.+ */+ path: string;++ /**+ * When set to `minimal`, only record information necessary for routing from HAR. This omits sizes, timing, page,+ * cookies, security and other types of HAR information that are not used when replaying from HAR. Defaults to `full`.+ */+ mode?: "full"|"minimal";++ /**+ * A glob or regex pattern to filter requests that are stored in the HAR. When a+ * [`baseURL`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-base-url) via the context+ * options was provided and the passed URL is a path, it gets merged via the+ * [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor. Defaults to none.+ */+ urlFilter?: string|RegExp;+ };++ /**+ * Enables video recording for all pages into `recordVideo.dir` directory. If not specified videos are not recorded.+ * Make sure to await+ * [browserContext.close([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-close) for+ * videos to be saved.+ */+ recordVideo?: {+ /**+ * Path to the directory to put videos into.+ */+ dir: string;++ /**+ * Optional dimensions of the recorded videos. If not specified the size will be equal to `viewport` scaled down to+ * fit into 800x800. If `viewport` is not configured explicitly the video size defaults to 800x450. Actual picture of+ * each page will be scaled down if necessary to fit the specified size.+ */+ size?: {+ /**+ * Video frame width.+ */+ width: number;++ /**+ * Video frame height.+ */+ height: number;+ };+ };++ /**+ * Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See+ * [page.emulateMedia([options])](https://playwright.dev/docs/api/class-page#page-emulate-media) for more details.+ * Passing `null` resets emulation to system defaults. Defaults to `'no-preference'`.+ */+ reducedMotion?: null|"reduce"|"no-preference";++ /**+ * Emulates consistent window screen size available inside web page via `window.screen`. Is only used when the+ * [`viewport`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-viewport) is set.+ */+ screen?: {+ /**+ * page width in pixels.+ */+ width: number;++ /**+ * page height in pixels.+ */+ height: number;+ };++ /**+ * Whether to allow sites to register Service workers. Defaults to `'allow'`.+ * - `'allow'`: [Service Workers](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) can be+ * registered.+ * - `'block'`: Playwright will block all registration of Service Workers.+ */+ serviceWorkers?: "allow"|"block";++ /**+ * Learn more about [storage state and auth](https://playwright.dev/docs/auth).+ *+ * Populates context with given storage state. This option can be used to initialize context with logged-in+ * information obtained via+ * [browserContext.storageState([options])](https://playwright.dev/docs/api/class-browsercontext#browser-context-storage-state).+ */+ storageState?: string|{+ /**+ * Cookies to set for context+ */+ cookies: Array<{+ name: string;++ value: string;++ /**+ * Domain and path are required. For the cookie to apply to all subdomains as well, prefix domain with a dot, like+ * this: ".example.com"+ */+ domain: string;++ /**+ * Domain and path are required+ */+ path: string;++ /**+ * Unix time in seconds.+ */+ expires: number;++ httpOnly: boolean;++ secure: boolean;++ /**+ * sameSite flag+ */+ sameSite: "Strict"|"Lax"|"None";+ }>;++ origins: Array<{+ origin: string;++ /**+ * localStorage to set for context+ */+ localStorage: Array<{+ name: string;++ value: string;+ }>;++ /**+ * indexedDB to set for context+ */+ indexedDB?: Array<{+ /**+ * database name+ */+ name: string;++ /**+ * database version+ */+ version: number;++ stores: Array<{+ name: string;++ keyPath?: string;++ keyPathArray?: Array<string>;++ autoIncrement: boolean;++ indexes: Array<{+ name: string;++ keyPath?: string;++ keyPathArray?: Array<string>;++ unique: boolean;++ multiEntry: boolean;+ }>;++ records: Array<{+ key?: Object;++ /**+ * if `key` is not JSON-serializable, this contains an encoded version that preserves types.+ */+ keyEncoded?: Object;++ value?: Object;++ /**+ * if `value` is not JSON-serializable, this contains an encoded version that preserves types.+ */+ valueEncoded?: Object;+ }>;+ }>;+ }>;+ }>;+ };++ /**+ * If set to true, enables strict selectors mode for this context. In the strict selectors mode all operations on+ * selectors that imply single target DOM element will throw when more than one element matches the selector. This+ * option does not affect any Locator APIs (Locators are always strict). Defaults to `false`. See+ * [Locator](https://playwright.dev/docs/api/class-locator) to learn more about the strict mode.+ */+ strictSelectors?: boolean;++ /**+ * Changes the timezone of the context. See+ * [ICU's metaZones.txt](https://cs.chromium.org/chromium/src/third_party/icu/source/data/misc/metaZones.txt?rcl=faee8bc70570192d82d2978a71e2a615788597d1)+ * for a list of supported timezone IDs. Defaults to the system timezone.+ */+ timezoneId?: string;++ /**+ * Specific user agent to use in this context.+ */+ userAgent?: string;++ /**+ * @deprecated Use [`recordVideo`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-record-video) instead.+ */+ videoSize?: {+ /**+ * Video frame width.+ */+ width: number;++ /**+ * Video frame height.+ */+ height: number;+ };++ /**+ * @deprecated Use [`recordVideo`](https://playwright.dev/docs/api/class-browser#browser-new-context-option-record-video) instead.+ */+ videosPath?: string;++ /**+ * Emulates consistent viewport for each page. Defaults to an 1280x720 viewport. Use `null` to disable the consistent+ * viewport emulation. Learn more about [viewport emulation](https://playwright.dev/docs/emulation#viewport).+ *+ * **NOTE** The `null` value opts out from the default presets, makes viewport depend on the host window size defined+ * by the operating system. It makes the execution of the tests non-deterministic.+ *+ */+ viewport?: null|ViewportSize;+}++export interface ViewportSize {+ /**+ * page width in pixels.+ */+ width: number;++ /**+ * page height in pixels.+ */+ height: number;+}++export interface HTTPCredentials {+ username: string;++ password: string;++ /**+ * Restrain sending http credentials on specific origin (scheme://host:port).+ */+ origin?: string;++ /**+ * This option only applies to the requests sent from corresponding+ * [APIRequestContext](https://playwright.dev/docs/api/class-apirequestcontext) and does not affect requests sent from+ * the browser. `'always'` - `Authorization` header with basic authentication credentials will be sent with the each+ * API request. `'unauthorized` - the credentials are only sent when 401 (Unauthorized) response with+ * `WWW-Authenticate` header is received. Defaults to `'unauthorized'`.+ */+ send?: "unauthorized"|"always";+}++export interface Geolocation {+ /**+ * Latitude between -90 and 90.+ */+ latitude: number;++ /**+ * Longitude between -180 and 180.+ */+ longitude: number;++ /**+ * Non-negative accuracy value. Defaults to `0`.+ */+ accuracy?: number;+}++export interface Cookie {+ name: string;++ value: string;++ domain: string;++ path: string;++ /**+ * Unix time in seconds.+ */+ expires: number;++ httpOnly: boolean;++ secure: boolean;++ sameSite: "Strict"|"Lax"|"None";+}++interface PageWaitForSelectorOptions {+ /**+ * Defaults to `'visible'`. Can be either:+ * - `'attached'` - wait for element to be present in DOM.+ * - `'detached'` - wait for element to not be present in DOM.+ * - `'visible'` - wait for element to have non-empty bounding box and no `visibility:hidden`. Note that element+ * without any content or with `display:none` has an empty bounding box and is not considered visible.+ * - `'hidden'` - wait for element to be either detached from DOM, or have an empty bounding box or+ * `visibility:hidden`. This is opposite to the `'visible'` option.+ */+ state?: "attached"|"detached"|"visible"|"hidden";++ /**+ * When true, the call requires selector to resolve to a single element. If given selector resolves to more than one+ * element, the call throws an exception.+ */+ strict?: boolean;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+}++interface PageWaitForFunctionOptions {+ /**+ * If [`polling`](https://playwright.dev/docs/api/class-page#page-wait-for-function-option-polling) is `'raf'`, then+ * [`pageFunction`](https://playwright.dev/docs/api/class-page#page-wait-for-function-option-expression) is constantly+ * executed in `requestAnimationFrame` callback. If+ * [`polling`](https://playwright.dev/docs/api/class-page#page-wait-for-function-option-polling) is a number, then it+ * is treated as an interval in milliseconds at which the function would be executed. Defaults to `raf`.+ */+ polling?: number|"raf";++ /**+ * Maximum time to wait for in milliseconds. Defaults to `0` - no timeout. The default value can be changed via+ * `actionTimeout` option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;+}++export interface PageScreenshotOptions {+ /**+ * When set to `"disabled"`, stops CSS animations, CSS transitions and Web Animations. Animations get different+ * treatment depending on their duration:+ * - finite animations are fast-forwarded to completion, so they'll fire `transitionend` event.+ * - infinite animations are canceled to initial state, and then played over after the screenshot.+ *+ * Defaults to `"allow"` that leaves animations untouched.+ */+ animations?: "disabled"|"allow";++ /**+ * When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be+ * changed. Defaults to `"hide"`.+ */+ caret?: "hide"|"initial";++ /**+ * An object which specifies clipping of the resulting image.+ */+ clip?: {+ /**+ * x-coordinate of top-left corner of clip area+ */+ x: number;++ /**+ * y-coordinate of top-left corner of clip area+ */+ y: number;++ /**+ * width of clipping area+ */+ width: number;++ /**+ * height of clipping area+ */+ height: number;+ };++ /**+ * When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Defaults to+ * `false`.+ */+ fullPage?: boolean;++ /**+ * Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink+ * box `#FF00FF` (customized by+ * [`maskColor`](https://playwright.dev/docs/api/class-page#page-screenshot-option-mask-color)) that completely covers+ * its bounding box.+ */+ mask?: Array<Locator>;++ /**+ * Specify the color of the overlay box for masked elements, in+ * [CSS color format](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value). Default color is pink `#FF00FF`.+ */+ maskColor?: string;++ /**+ * Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images.+ * Defaults to `false`.+ */+ omitBackground?: boolean;++ /**+ * The file path to save the image to. The screenshot type will be inferred from file extension. If+ * [`path`](https://playwright.dev/docs/api/class-page#page-screenshot-option-path) is a relative path, then it is+ * resolved relative to the current working directory. If no path is provided, the image won't be saved to the disk.+ */+ path?: string;++ /**+ * The quality of the image, between 0-100. Not applicable to `png` images.+ */+ quality?: number;++ /**+ * When set to `"css"`, screenshot will have a single pixel per each css pixel on the page. For high-dpi devices, this+ * will keep screenshots small. Using `"device"` option will produce a single pixel per each device pixel, so+ * screenshots of high-dpi devices will be twice as large or even larger.+ *+ * Defaults to `"device"`.+ */+ scale?: "css"|"device";++ /**+ * Text of the stylesheet to apply while making the screenshot. This is where you can hide dynamic elements, make+ * elements invisible or change their properties to help you creating repeatable screenshots. This stylesheet pierces+ * the Shadow DOM and applies to the inner frames.+ */+ style?: string;++ /**+ * Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout`+ * option in the config, or by using the+ * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)+ * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.+ */+ timeout?: number;++ /**+ * Specify screenshot type, defaults to `png`.+ */+ type?: "png"|"jpeg";+}++type Devices = {+ "Blackberry PlayBook": DeviceDescriptor;+ "Blackberry PlayBook landscape": DeviceDescriptor;+ "BlackBerry Z30": DeviceDescriptor;+ "BlackBerry Z30 landscape": DeviceDescriptor;+ "Galaxy Note 3": DeviceDescriptor;+ "Galaxy Note 3 landscape": DeviceDescriptor;+ "Galaxy Note II": DeviceDescriptor;+ "Galaxy Note II landscape": DeviceDescriptor;+ "Galaxy S III": DeviceDescriptor;+ "Galaxy S III landscape": DeviceDescriptor;+ "Galaxy S5": DeviceDescriptor;+ "Galaxy S5 landscape": DeviceDescriptor;+ "Galaxy S8": DeviceDescriptor;+ "Galaxy S8 landscape": DeviceDescriptor;+ "Galaxy S9+": DeviceDescriptor;+ "Galaxy S9+ landscape": DeviceDescriptor;+ "Galaxy Tab S4": DeviceDescriptor;+ "Galaxy Tab S4 landscape": DeviceDescriptor;+ "iPad (gen 5)": DeviceDescriptor;+ "iPad (gen 5) landscape": DeviceDescriptor;+ "iPad (gen 6)": DeviceDescriptor;+ "iPad (gen 6) landscape": DeviceDescriptor;+ "iPad (gen 7)": DeviceDescriptor;+ "iPad (gen 7) landscape": DeviceDescriptor;+ "iPad Mini": DeviceDescriptor;+ "iPad Mini landscape": DeviceDescriptor;+ "iPad Pro 11": DeviceDescriptor;+ "iPad Pro 11 landscape": DeviceDescriptor;+ "iPhone 6": DeviceDescriptor;+ "iPhone 6 landscape": DeviceDescriptor;+ "iPhone 6 Plus": DeviceDescriptor;+ "iPhone 6 Plus landscape": DeviceDescriptor;+ "iPhone 7": DeviceDescriptor;+ "iPhone 7 landscape": DeviceDescriptor;+ "iPhone 7 Plus": DeviceDescriptor;+ "iPhone 7 Plus landscape": DeviceDescriptor;+ "iPhone 8": DeviceDescriptor;+ "iPhone 8 landscape": DeviceDescriptor;+ "iPhone 8 Plus": DeviceDescriptor;+ "iPhone 8 Plus landscape": DeviceDescriptor;+ "iPhone SE": DeviceDescriptor;+ "iPhone SE landscape": DeviceDescriptor;+ "iPhone X": DeviceDescriptor;+ "iPhone X landscape": DeviceDescriptor;+ "iPhone XR": DeviceDescriptor;+ "iPhone XR landscape": DeviceDescriptor;+ "iPhone 11": DeviceDescriptor;+ "iPhone 11 landscape": DeviceDescriptor;+ "iPhone 11 Pro": DeviceDescriptor;+ "iPhone 11 Pro landscape": DeviceDescriptor;+ "iPhone 11 Pro Max": DeviceDescriptor;+ "iPhone 11 Pro Max landscape": DeviceDescriptor;+ "iPhone 12": DeviceDescriptor;+ "iPhone 12 landscape": DeviceDescriptor;+ "iPhone 12 Pro": DeviceDescriptor;+ "iPhone 12 Pro landscape": DeviceDescriptor;+ "iPhone 12 Pro Max": DeviceDescriptor;+ "iPhone 12 Pro Max landscape": DeviceDescriptor;+ "iPhone 12 Mini": DeviceDescriptor;+ "iPhone 12 Mini landscape": DeviceDescriptor;+ "iPhone 13": DeviceDescriptor;+ "iPhone 13 landscape": DeviceDescriptor;+ "iPhone 13 Pro": DeviceDescriptor;+ "iPhone 13 Pro landscape": DeviceDescriptor;+ "iPhone 13 Pro Max": DeviceDescriptor;+ "iPhone 13 Pro Max landscape": DeviceDescriptor;+ "iPhone 13 Mini": DeviceDescriptor;+ "iPhone 13 Mini landscape": DeviceDescriptor;+ "iPhone 14": DeviceDescriptor;+ "iPhone 14 landscape": DeviceDescriptor;+ "iPhone 14 Plus": DeviceDescriptor;+ "iPhone 14 Plus landscape": DeviceDescriptor;+ "iPhone 14 Pro": DeviceDescriptor;+ "iPhone 14 Pro landscape": DeviceDescriptor;+ "iPhone 14 Pro Max": DeviceDescriptor;+ "iPhone 14 Pro Max landscape": DeviceDescriptor;+ "iPhone 15": DeviceDescriptor;+ "iPhone 15 landscape": DeviceDescriptor;+ "iPhone 15 Plus": DeviceDescriptor;+ "iPhone 15 Plus landscape": DeviceDescriptor;+ "iPhone 15 Pro": DeviceDescriptor;+ "iPhone 15 Pro landscape": DeviceDescriptor;+ "iPhone 15 Pro Max": DeviceDescriptor;+ "iPhone 15 Pro Max landscape": DeviceDescriptor;+ "Kindle Fire HDX": DeviceDescriptor;+ "Kindle Fire HDX landscape": DeviceDescriptor;+ "LG Optimus L70": DeviceDescriptor;+ "LG Optimus L70 landscape": DeviceDescriptor;+ "Microsoft Lumia 550": DeviceDescriptor;+ "Microsoft Lumia 550 landscape": DeviceDescriptor;+ "Microsoft Lumia 950": DeviceDescriptor;+ "Microsoft Lumia 950 landscape": DeviceDescriptor;+ "Nexus 10": DeviceDescriptor;+ "Nexus 10 landscape": DeviceDescriptor;+ "Nexus 4": DeviceDescriptor;+ "Nexus 4 landscape": DeviceDescriptor;+ "Nexus 5": DeviceDescriptor;+ "Nexus 5 landscape": DeviceDescriptor;+ "Nexus 5X": DeviceDescriptor;+ "Nexus 5X landscape": DeviceDescriptor;+ "Nexus 6": DeviceDescriptor;+ "Nexus 6 landscape": DeviceDescriptor;+ "Nexus 6P": DeviceDescriptor;+ "Nexus 6P landscape": DeviceDescriptor;+ "Nexus 7": DeviceDescriptor;+ "Nexus 7 landscape": DeviceDescriptor;+ "Nokia Lumia 520": DeviceDescriptor;+ "Nokia Lumia 520 landscape": DeviceDescriptor;+ "Nokia N9": DeviceDescriptor;+ "Nokia N9 landscape": DeviceDescriptor;+ "Pixel 2": DeviceDescriptor;+ "Pixel 2 landscape": DeviceDescriptor;+ "Pixel 2 XL": DeviceDescriptor;+ "Pixel 2 XL landscape": DeviceDescriptor;+ "Pixel 3": DeviceDescriptor;+ "Pixel 3 landscape": DeviceDescriptor;+ "Pixel 4": DeviceDescriptor;+ "Pixel 4 landscape": DeviceDescriptor;+ "Pixel 4a (5G)": DeviceDescriptor;+ "Pixel 4a (5G) landscape": DeviceDescriptor;+ "Pixel 5": DeviceDescriptor;+ "Pixel 5 landscape": DeviceDescriptor;+ "Pixel 7": DeviceDescriptor;+ "Pixel 7 landscape": DeviceDescriptor;+ "Moto G4": DeviceDescriptor;+ "Moto G4 landscape": DeviceDescriptor;+ "Desktop Chrome HiDPI": DeviceDescriptor;+ "Desktop Edge HiDPI": DeviceDescriptor;+ "Desktop Firefox HiDPI": DeviceDescriptor;+ "Desktop Safari": DeviceDescriptor;+ "Desktop Chrome": DeviceDescriptor;+ "Desktop Edge": DeviceDescriptor;+ "Desktop Firefox": DeviceDescriptor;+ [key: string]: DeviceDescriptor;+}++export interface ChromiumBrowserContext extends BrowserContext { }+export interface ChromiumBrowser extends Browser { }+export interface FirefoxBrowser extends Browser { }+export interface WebKitBrowser extends Browser { }+export interface ChromiumCoverage extends Coverage { }diff --git a/packages/playwright-core/src/client/platform.ts b/packages/playwright-core/src/client/platform.tsindex e9d47c5692..5228e8a358 100644--- a/packages/playwright-core/src/client/platform.ts+++ b/packages/playwright-core/src/client/platform.ts@@ -14,7 +14,7 @@* limitations under the License.*/-import { webColors, noColors } from '../utils/isomorphic/colors';+import { webColors } from '../utils/isomorphic/colors';import type * as fs from 'fs';import type * as path from 'path';@@ -71,7 +71,7 @@ export const emptyPlatform: Platform = {throw new Error('Not implemented');},- colors: noColors,+ colors: webColors,createGuid: () => {throw new Error('Not implemented');@@ -121,23 +121,3 @@ export const emptyPlatform: Platform = {zones: { empty: noopZone, current: () => noopZone },};--export const webPlatform: Platform = {- ...emptyPlatform,-- name: 'web',-- boxedStackPrefixes: () => [],-- calculateSha1: async (text: string) => {- const bytes = new TextEncoder().encode(text);- const hashBuffer = await window.crypto.subtle.digest('SHA-1', bytes);- return Array.from(new Uint8Array(hashBuffer), b => b.toString(16).padStart(2, '0')).join('');- },-- colors: webColors,-- createGuid: () => {- return Array.from(window.crypto.getRandomValues(new Uint8Array(16)), b => b.toString(16).padStart(2, '0')).join('');- },-};diff --git a/packages/playwright-core/src/client/playwright.ts b/packages/playwright-core/src/client/playwright.tsindex 3a0e359a0e..1b9bd87cc5 100644--- a/packages/playwright-core/src/client/playwright.ts+++ b/packages/playwright-core/src/client/playwright.ts@@ -15,6 +15,7 @@*/import { Android } from './android';+import { Browser } from './browser';import { BrowserType } from './browserType';import { ChannelOwner } from './channelOwner';import { Electron } from './electron';@@ -86,6 +87,12 @@ export class Playwright extends ChannelOwner<channels.PlaywrightChannel> {return [this.chromium, this.firefox, this.webkit, this._bidiChromium, this._bidiFirefox];}+ _preLaunchedBrowser(): Browser {+ const browser = Browser.from(this._initializer.preLaunchedBrowser!);+ browser._browserType = this[browser._name as 'chromium' | 'firefox' | 'webkit'];+ return browser;+ }+_allContexts() {return this._browserTypes().flatMap(type => [...type._contexts]);}diff --git a/packages/playwright-core/src/inProcessFactory.ts b/packages/playwright-core/src/inProcessFactory.tsindex 5e5bad19e9..e6ef380b71 100644--- a/packages/playwright-core/src/inProcessFactory.ts+++ b/packages/playwright-core/src/inProcessFactory.ts@@ -16,19 +16,18 @@import { AndroidServerLauncherImpl } from './androidServerImpl';import { BrowserServerLauncherImpl } from './browserServerImpl';-import { createConnectionFactory } from './client/clientBundle';import { DispatcherConnection, PlaywrightDispatcher, RootDispatcher, createPlaywright } from './server';import { nodePlatform } from './server/utils/nodePlatform';+import { Connection } from './client/connection';+import { setPlatformForSelectors } from './client/selectors';import type { Playwright as PlaywrightAPI } from './client/playwright';import type { Language } from './utils';-const connectionFactory = createConnectionFactory(nodePlatform);-export function createInProcessPlaywright(): PlaywrightAPI {const playwright = createPlaywright({ sdkLanguage: (process.env.PW_LANG_NAME as Language | undefined) || 'javascript' });-- const clientConnection = connectionFactory();+ setPlatformForSelectors(nodePlatform);+ const clientConnection = new Connection(nodePlatform);clientConnection.useRawBuffers();const dispatcherConnection = new DispatcherConnection(true /* local */);diff --git a/packages/playwright-core/src/outofprocess.ts b/packages/playwright-core/src/outofprocess.tsindex 7225bbb569..a5f0bc45c9 100644--- a/packages/playwright-core/src/outofprocess.ts+++ b/packages/playwright-core/src/outofprocess.ts@@ -17,16 +17,17 @@import * as childProcess from 'child_process';import path from 'path';-import { createConnectionFactory } from './client/clientBundle';+import { Connection } from './client/connection';import { PipeTransport } from './server/utils/pipeTransport';import { ManualPromise } from './utils/isomorphic/manualPromise';import { nodePlatform } from './server/utils/nodePlatform';+import { setPlatformForSelectors } from './client/selectors';import type { Playwright } from './client/playwright';-const connectionFactory = createConnectionFactory(nodePlatform);export async function start(env: any = {}): Promise<{ playwright: Playwright, stop: () => Promise<void> }> {+ setPlatformForSelectors(nodePlatform);const client = new PlaywrightClient(env);const playwright = await client._playwright;(playwright as any).driverProcess = client._driverProcess;@@ -50,7 +51,7 @@ class PlaywrightClient {this._driverProcess.unref();this._driverProcess.stderr!.on('data', data => process.stderr.write(data));- const connection = connectionFactory();+ const connection = new Connection(nodePlatform);const transport = new PipeTransport(this._driverProcess.stdin!, this._driverProcess.stdout!);connection.onmessage = message => transport.send(JSON.stringify(message));transport.onmessage = message => connection.dispatch(JSON.parse(message));diff --git a/packages/playwright-core/types/types.d.ts b/packages/playwright-core/types/types.d.tsindex 9ba88071f4..65907853f4 100644--- a/packages/playwright-core/types/types.d.ts+++ b/packages/playwright-core/types/types.d.ts@@ -15,7 +15,6 @@* limitations under the License.*/import { ChildProcess } from 'child_process';-import { EventEmitter } from 'events';import { Readable } from 'stream';import { ReadStream } from 'fs';import { Protocol } from './protocol';diff --git a/utils/build/build.js b/utils/build/build.jsindex b67b36aee3..71dddac55f 100644--- a/utils/build/build.js+++ b/utils/build/build.js@@ -275,6 +275,19 @@ for (const bundle of bundles) {});}+// Build/watch playwright-client.+steps.push({+ command: 'npm',+ args: [+ 'run',+ watchMode ? 'watch' : 'build',+ ...(withSourceMaps ? ['--', '--sourcemap'] : [])+ ],+ shell: true,+ cwd: path.join(__dirname, '..', '..', 'packages', 'playwright-client'),+ concurrent: true,+});+// Build/watch trace viewer service worker.steps.push({command: 'npx',diff --git a/utils/generate_types/index.js b/utils/generate_types/index.jsindex b3ad1c4f23..c90a64cebb 100644--- a/utils/generate_types/index.js+++ b/utils/generate_types/index.js@@ -622,13 +622,16 @@ class TypesGenerator {}const coreTypesDir = path.join(PROJECT_DIR, 'packages', 'playwright-core', 'types');+ const clientTypesDir = path.join(PROJECT_DIR, 'packages', 'playwright-client', 'types');if (!fs.existsSync(coreTypesDir))fs.mkdirSync(coreTypesDir)const playwrightTypesDir = path.join(PROJECT_DIR, 'packages', 'playwright', 'types');if (!fs.existsSync(playwrightTypesDir))fs.mkdirSync(playwrightTypesDir)writeFile(path.join(coreTypesDir, 'protocol.d.ts'), fs.readFileSync(path.join(PROJECT_DIR, 'packages', 'playwright-core', 'src', 'server', 'chromium', 'protocol.d.ts'), 'utf8'), false);- writeFile(path.join(coreTypesDir, 'types.d.ts'), await generateCoreTypes(), true);+ const coreTypes = await generateCoreTypes();+ writeFile(path.join(coreTypesDir, 'types.d.ts'), coreTypes, true);+ writeFile(path.join(clientTypesDir, 'types.d.ts'), coreTypes, true);writeFile(path.join(playwrightTypesDir, 'test.d.ts'), await generateTestTypes(), true);writeFile(path.join(playwrightTypesDir, 'testReporter.d.ts'), await generateReporterTypes(), true);process.exit(0);diff --git a/utils/generate_types/overrides.d.ts b/utils/generate_types/overrides.d.tsindex 825db884a1..de8c95376b 100644--- a/utils/generate_types/overrides.d.ts+++ b/utils/generate_types/overrides.d.ts@@ -14,7 +14,6 @@* limitations under the License.*/import { ChildProcess } from 'child_process';-import { EventEmitter } from 'events';import { Readable } from 'stream';import { ReadStream } from 'fs';import { Protocol } from './protocol';diff --git a/utils/kill_watch.sh b/utils/kill_watch.shnew file mode 100755index 0000000000..37e4fef871--- /dev/null+++ b/utils/kill_watch.sh@@ -0,0 +1,3 @@+#!/bin/sh+ps ax | grep playwright | grep "vite\|tsc\|babel\|esbuild" | sed 's|pts/.*||' | xargs kill+